wradmin/wradmin/public/yui/editor/editor-debug.js

   1 /*
   2 Copyright (c) 2009, Yahoo! Inc. All rights reserved.
   3 Code licensed under the BSD License:
   4 http://developer.yahoo.net/yui/license.txt
   5 version: 2.7.0
   6 */
   7 (function() {
   8 var Dom = YAHOO.util.Dom,
   9     Event = YAHOO.util.Event,
  10     Lang = YAHOO.lang;
  11     /**
  12      * @module editor
  13      * @description <p>Creates a rich custom Toolbar Button. Primarily used with the Rich Text Editor's Toolbar</p>
  14      * @class ToolbarButtonAdvanced
  15      * @namespace YAHOO.widget
  16      * @requires yahoo, dom, element, event, container_core, menu, button
  17      *
  18      * Provides a toolbar button based on the button and menu widgets.
  19      * @constructor
  20      * @class ToolbarButtonAdvanced
  21      * @param {String/HTMLElement} el The element to turn into a button.
  22      * @param {Object} attrs Object liternal containing configuration parameters.
  23     */
  24     if (YAHOO.widget.Button) {
  25         YAHOO.widget.ToolbarButtonAdvanced = YAHOO.widget.Button;
  26         /**
  27         * @property buttonType
  28         * @private
  29         * @description Tells if the Button is a Rich Button or a Simple Button
  30         */
  31         YAHOO.widget.ToolbarButtonAdvanced.prototype.buttonType = 'rich';
  32         /**
  33         * @method checkValue
  34         * @param {String} value The value of the option that we want to mark as selected
  35         * @description Select an option by value
  36         */
  37         YAHOO.widget.ToolbarButtonAdvanced.prototype.checkValue = function(value) {
  38             var _menuItems = this.getMenu().getItems();
  39             if (_menuItems.length === 0) {
  40                 this.getMenu()._onBeforeShow();
  41                 _menuItems = this.getMenu().getItems();
  42             }
  43             for (var i = 0; i < _menuItems.length; i++) {
  44                 _menuItems[i].cfg.setProperty('checked', false);
  45                 if (_menuItems[i].value == value) {
  46                     _menuItems[i].cfg.setProperty('checked', true);
  47                 }
  48             }
  49         };
  50     } else {
  51         YAHOO.widget.ToolbarButtonAdvanced = function() {};
  52     }
  53
  54
  55     /**
  56      * @description <p>Creates a basic custom Toolbar Button. Primarily used with the Rich Text Editor's Toolbar</p><p>Provides a toolbar button based on the button and menu widgets, &lt;select&gt; elements are used in place of menu's.</p>
  57      * @class ToolbarButton
  58      * @namespace YAHOO.widget
  59      * @requires yahoo, dom, element, event
  60      * @extends YAHOO.util.Element
  61      *
  62      *
  63      * @constructor
  64      * @param {String/HTMLElement} el The element to turn into a button.
  65      * @param {Object} attrs Object liternal containing configuration parameters.
  66     */
  67
  68     YAHOO.widget.ToolbarButton = function(el, attrs) {
  69         YAHOO.log('ToolbarButton Initalizing', 'info', 'ToolbarButton');
  70         YAHOO.log(arguments.length + ' arguments passed to constructor', 'info', 'Toolbar');
  71
  72         if (Lang.isObject(arguments[0]) && !Dom.get(el).nodeType) {
  73             attrs = el;
  74         }
  75         var local_attrs = (attrs || {});
  76
  77         var oConfig = {
  78             element: null,
  79             attributes: local_attrs
  80         };
  81
  82         if (!oConfig.attributes.type) {
  83             oConfig.attributes.type = 'push';
  84         }
  85
  86         oConfig.element = document.createElement('span');
  87         oConfig.element.setAttribute('unselectable', 'on');
  88         oConfig.element.className = 'yui-button yui-' + oConfig.attributes.type + '-button';
  89         oConfig.element.innerHTML = '<span class="first-child"><a href="#">LABEL</a></span>';
  90         oConfig.element.firstChild.firstChild.tabIndex = '-1';
  91         oConfig.attributes.id = (oConfig.attributes.id || Dom.generateId());
  92         oConfig.element.id = oConfig.attributes.id;
  93
  94         YAHOO.widget.ToolbarButton.superclass.constructor.call(this, oConfig.element, oConfig.attributes);
  95     };
  96
  97     YAHOO.extend(YAHOO.widget.ToolbarButton, YAHOO.util.Element, {
  98         /**
  99         * @property buttonType
 100         * @private
 101         * @description Tells if the Button is a Rich Button or a Simple Button
 102         */
 103         buttonType: 'normal',
 104         /**
 105         * @method _handleMouseOver
 106         * @private
 107         * @description Adds classes to the button elements on mouseover (hover)
 108         */
 109         _handleMouseOver: function() {
 110             if (!this.get('disabled')) {
 111                 this.addClass('yui-button-hover');
 112                 this.addClass('yui-' + this.get('type') + '-button-hover');
 113             }
 114         },
 115         /**
 116         * @method _handleMouseOut
 117         * @private
 118         * @description Removes classes from the button elements on mouseout (hover)
 119         */
 120         _handleMouseOut: function() {
 121             this.removeClass('yui-button-hover');
 122             this.removeClass('yui-' + this.get('type') + '-button-hover');
 123         },
 124         /**
 125         * @method checkValue
 126         * @param {String} value The value of the option that we want to mark as selected
 127         * @description Select an option by value
 128         */
 129         checkValue: function(value) {
 130             if (this.get('type') == 'menu') {
 131                 var opts = this._button.options;
 132                 for (var i = 0; i < opts.length; i++) {
 133                     if (opts[i].value == value) {
 134                         opts.selectedIndex = i;
 135                     }
 136                 }
 137             }
 138         },
 139         /**
 140         * @method init
 141         * @description The ToolbarButton class's initialization method
 142         */
 143         init: function(p_oElement, p_oAttributes) {
 144             YAHOO.widget.ToolbarButton.superclass.init.call(this, p_oElement, p_oAttributes);
 145
 146             this.on('mouseover', this._handleMouseOver, this, true);
 147             this.on('mouseout', this._handleMouseOut, this, true);
 148             this.on('click', function(ev) {
 149                 Event.stopEvent(ev);
 150                 return false;
 151             }, this, true);
 152         },
 153         /**
 154         * @method initAttributes
 155         * @description Initializes all of the configuration attributes used to create
 156         * the toolbar.
 157         * @param {Object} attr Object literal specifying a set of
 158         * configuration attributes used to create the toolbar.
 159         */
 160         initAttributes: function(attr) {
 161             YAHOO.widget.ToolbarButton.superclass.initAttributes.call(this, attr);
 162             /**
 163             * @attribute value
 164             * @description The value of the button
 165             * @type String
 166             */
 167             this.setAttributeConfig('value', {
 168                 value: attr.value
 169             });
 170             /**
 171             * @attribute menu
 172             * @description The menu attribute, see YAHOO.widget.Button
 173             * @type Object
 174             */
 175             this.setAttributeConfig('menu', {
 176                 value: attr.menu || false
 177             });
 178             /**
 179             * @attribute type
 180             * @description The type of button to create: push, menu, color, select, spin
 181             * @type String
 182             */
 183             this.setAttributeConfig('type', {
 184                 value: attr.type,
 185                 writeOnce: true,
 186                 method: function(type) {
 187                     var el, opt;
 188                     if (!this._button) {
 189                         this._button = this.get('element').getElementsByTagName('a')[0];
 190                     }
 191                     switch (type) {
 192                         case 'select':
 193                         case 'menu':
 194                             el = document.createElement('select');
 195                             var menu = this.get('menu');
 196                             for (var i = 0; i < menu.length; i++) {
 197                                 opt = document.createElement('option');
 198                                 opt.innerHTML = menu[i].text;
 199                                 opt.value = menu[i].value;
 200                                 if (menu[i].checked) {
 201                                     opt.selected = true;
 202                                 }
 203                                 el.appendChild(opt);
 204                             }
 205                             this._button.parentNode.replaceChild(el, this._button);
 206                             Event.on(el, 'change', this._handleSelect, this, true);
 207                             this._button = el;
 208                             break;
 209                     }
 210                 }
 211             });
 212
 213             /**
 214             * @attribute disabled
 215             * @description Set the button into a disabled state
 216             * @type String
 217             */
 218             this.setAttributeConfig('disabled', {
 219                 value: attr.disabled || false,
 220                 method: function(disabled) {
 221                     if (disabled) {
 222                         this.addClass('yui-button-disabled');
 223                         this.addClass('yui-' + this.get('type') + '-button-disabled');
 224                     } else {
 225                         this.removeClass('yui-button-disabled');
 226                         this.removeClass('yui-' + this.get('type') + '-button-disabled');
 227                     }
 228                     if (this.get('type') == 'menu') {
 229                         this._button.disabled = disabled;
 230                     }
 231                 }
 232             });
 233
 234             /**
 235             * @attribute label
 236             * @description The text label for the button
 237             * @type String
 238             */
 239             this.setAttributeConfig('label', {
 240                 value: attr.label,
 241                 method: function(label) {
 242                     if (!this._button) {
 243                         this._button = this.get('element').getElementsByTagName('a')[0];
 244                     }
 245                     if (this.get('type') == 'push') {
 246                         this._button.innerHTML = label;
 247                     }
 248                 }
 249             });
 250
 251             /**
 252             * @attribute title
 253             * @description The title of the button
 254             * @type String
 255             */
 256             this.setAttributeConfig('title', {
 257                 value: attr.title
 258             });
 259
 260             /**
 261             * @config container
 262             * @description The container that the button is rendered to, handled by Toolbar
 263             * @type String
 264             */
 265             this.setAttributeConfig('container', {
 266                 value: null,
 267                 writeOnce: true,
 268                 method: function(cont) {
 269                     this.appendTo(cont);
 270                 }
 271             });
 272
 273         },
 274         /**
 275         * @private
 276         * @method _handleSelect
 277         * @description The event fired when a change event gets fired on a select element
 278         * @param {Event} ev The change event.
 279         */
 280         _handleSelect: function(ev) {
 281             var tar = Event.getTarget(ev);
 282             var value = tar.options[tar.selectedIndex].value;
 283             this.fireEvent('change', {type: 'change', value: value });
 284         },
 285         /**
 286         * @method getMenu
 287         * @description A stub function to mimic YAHOO.widget.Button's getMenu method
 288         */
 289         getMenu: function() {
 290             return this.get('menu');
 291         },
 292         /**
 293         * @method destroy
 294         * @description Destroy the button
 295         */
 296         destroy: function() {
 297             Event.purgeElement(this.get('element'), true);
 298             this.get('element').parentNode.removeChild(this.get('element'));
 299             //Brutal Object Destroy
 300             for (var i in this) {
 301                 if (Lang.hasOwnProperty(this, i)) {
 302                     this[i] = null;
 303                 }
 304             }
 305         },
 306         /**
 307         * @method fireEvent
 308         * @description Overridden fireEvent method to prevent DOM events from firing if the button is disabled.
 309         */
 310         fireEvent: function(p_sType, p_aArgs) {
 311             //  Disabled buttons should not respond to DOM events
 312             if (this.DOM_EVENTS[p_sType] && this.get('disabled')) {
 313                 Event.stopEvent(p_aArgs);
 314                 return;
 315             }
 316
 317             YAHOO.widget.ToolbarButton.superclass.fireEvent.call(this, p_sType, p_aArgs);
 318         },
 319         /**
 320         * @method toString
 321         * @description Returns a string representing the toolbar.
 322         * @return {String}
 323         */
 324         toString: function() {
 325             return 'ToolbarButton (' + this.get('id') + ')';
 326         }
 327
 328     });
 329 })();
 330 /**
 331  * @module editor
 332  * @description <p>Creates a rich Toolbar widget based on Button. Primarily used with the Rich Text Editor</p>
 333  * @namespace YAHOO.widget
 334  * @requires yahoo, dom, element, event, toolbarbutton
 335  * @optional container_core, dragdrop
 336  */
 337 (function() {
 338 var Dom = YAHOO.util.Dom,
 339     Event = YAHOO.util.Event,
 340     Lang = YAHOO.lang;
 341
 342     var getButton = function(id) {
 343         var button = id;
 344         if (Lang.isString(id)) {
 345             button = this.getButtonById(id);
 346         }
 347         if (Lang.isNumber(id)) {
 348             button = this.getButtonByIndex(id);
 349         }
 350         if ((!(button instanceof YAHOO.widget.ToolbarButton)) && (!(button instanceof YAHOO.widget.ToolbarButtonAdvanced))) {
 351             button = this.getButtonByValue(id);
 352         }
 353         if ((button instanceof YAHOO.widget.ToolbarButton) || (button instanceof YAHOO.widget.ToolbarButtonAdvanced)) {
 354             return button;
 355         }
 356         return false;
 357     };
 358
 359     /**
 360      * Provides a rich toolbar widget based on the button and menu widgets
 361      * @constructor
 362      * @class Toolbar
 363      * @extends YAHOO.util.Element
 364      * @param {String/HTMLElement} el The element to turn into a toolbar.
 365      * @param {Object} attrs Object liternal containing configuration parameters.
 366     */
 367     YAHOO.widget.Toolbar = function(el, attrs) {
 368         YAHOO.log('Toolbar Initalizing', 'info', 'Toolbar');
 369         YAHOO.log(arguments.length + ' arguments passed to constructor', 'info', 'Toolbar');
 370
 371         if (Lang.isObject(arguments[0]) && !Dom.get(el).nodeType) {
 372             attrs = el;
 373         }
 374         var local_attrs = {};
 375         if (attrs) {
 376             Lang.augmentObject(local_attrs, attrs); //Break the config reference
 377         }
 378
 379
 380         var oConfig = {
 381             element: null,
 382             attributes: local_attrs
 383         };
 384
 385
 386         if (Lang.isString(el) && Dom.get(el)) {
 387             oConfig.element = Dom.get(el);
 388         } else if (Lang.isObject(el) && Dom.get(el) && Dom.get(el).nodeType) {
 389             oConfig.element = Dom.get(el);
 390         }
 391
 392
 393         if (!oConfig.element) {
 394             YAHOO.log('No element defined, creating toolbar container', 'warn', 'Toolbar');
 395             oConfig.element = document.createElement('DIV');
 396             oConfig.element.id = Dom.generateId();
 397
 398             if (local_attrs.container && Dom.get(local_attrs.container)) {
 399                 YAHOO.log('Container found in config appending to it (' + Dom.get(local_attrs.container).id + ')', 'info', 'Toolbar');
 400                 Dom.get(local_attrs.container).appendChild(oConfig.element);
 401             }
 402         }
 403
 404
 405         if (!oConfig.element.id) {
 406             oConfig.element.id = ((Lang.isString(el)) ? el : Dom.generateId());
 407             YAHOO.log('No element ID defined for toolbar container, creating..', 'warn', 'Toolbar');
 408         }
 409         YAHOO.log('Initing toolbar with id: ' + oConfig.element.id, 'info', 'Toolbar');
 410
 411         var fs = document.createElement('fieldset');
 412         var lg = document.createElement('legend');
 413         lg.innerHTML = 'Toolbar';
 414         fs.appendChild(lg);
 415
 416         var cont = document.createElement('DIV');
 417         oConfig.attributes.cont = cont;
 418         Dom.addClass(cont, 'yui-toolbar-subcont');
 419         fs.appendChild(cont);
 420         oConfig.element.appendChild(fs);
 421
 422         oConfig.element.tabIndex = -1;
 423
 424
 425         oConfig.attributes.element = oConfig.element;
 426         oConfig.attributes.id = oConfig.element.id;
 427
 428         YAHOO.widget.Toolbar.superclass.constructor.call(this, oConfig.element, oConfig.attributes);
 429
 430     };
 431
 432     YAHOO.extend(YAHOO.widget.Toolbar, YAHOO.util.Element, {
 433         /**
 434         * @method _addMenuClasses
 435         * @private
 436         * @description This method is called from Menu's renderEvent to add a few more classes to the menu items
 437         * @param {String} ev The event that fired.
 438         * @param {Array} na Array of event information.
 439         * @param {Object} o Button config object.
 440         */
 441         _addMenuClasses: function(ev, na, o) {
 442             Dom.addClass(this.element, 'yui-toolbar-' + o.get('value') + '-menu');
 443             if (Dom.hasClass(o._button.parentNode.parentNode, 'yui-toolbar-select')) {
 444                 Dom.addClass(this.element, 'yui-toolbar-select-menu');
 445             }
 446             var items = this.getItems();
 447             for (var i = 0; i < items.length; i++) {
 448                 Dom.addClass(items[i].element, 'yui-toolbar-' + o.get('value') + '-' + ((items[i].value) ? items[i].value.replace(/ /g, '-').toLowerCase() : items[i]._oText.nodeValue.replace(/ /g, '-').toLowerCase()));
 449                 Dom.addClass(items[i].element, 'yui-toolbar-' + o.get('value') + '-' + ((items[i].value) ? items[i].value.replace(/ /g, '-') : items[i]._oText.nodeValue.replace(/ /g, '-')));
 450             }
 451         },
 452         /**
 453         * @property buttonType
 454         * @description The default button to use
 455         * @type Object
 456         */
 457         buttonType: YAHOO.widget.ToolbarButton,
 458         /**
 459         * @property dd
 460         * @description The DragDrop instance associated with the Toolbar
 461         * @type Object
 462         */
 463         dd: null,
 464         /**
 465         * @property _colorData
 466         * @description Object reference containing colors hex and text values.
 467         * @type Object
 468         */
 469         _colorData: {
 470 /* {{{ _colorData */
 471     '#111111': 'Obsidian',
 472     '#2D2D2D': 'Dark Gray',
 473     '#434343': 'Shale',
 474     '#5B5B5B': 'Flint',
 475     '#737373': 'Gray',
 476     '#8B8B8B': 'Concrete',
 477     '#A2A2A2': 'Gray',
 478     '#B9B9B9': 'Titanium',
 479     '#000000': 'Black',
 480     '#D0D0D0': 'Light Gray',
 481     '#E6E6E6': 'Silver',
 482     '#FFFFFF': 'White',
 483     '#BFBF00': 'Pumpkin',
 484     '#FFFF00': 'Yellow',
 485     '#FFFF40': 'Banana',
 486     '#FFFF80': 'Pale Yellow',
 487     '#FFFFBF': 'Butter',
 488     '#525330': 'Raw Siena',
 489     '#898A49': 'Mildew',
 490     '#AEA945': 'Olive',
 491     '#7F7F00': 'Paprika',
 492     '#C3BE71': 'Earth',
 493     '#E0DCAA': 'Khaki',
 494     '#FCFAE1': 'Cream',
 495     '#60BF00': 'Cactus',
 496     '#80FF00': 'Chartreuse',
 497     '#A0FF40': 'Green',
 498     '#C0FF80': 'Pale Lime',
 499     '#DFFFBF': 'Light Mint',
 500     '#3B5738': 'Green',
 501     '#668F5A': 'Lime Gray',
 502     '#7F9757': 'Yellow',
 503     '#407F00': 'Clover',
 504     '#8A9B55': 'Pistachio',
 505     '#B7C296': 'Light Jade',
 506     '#E6EBD5': 'Breakwater',
 507     '#00BF00': 'Spring Frost',
 508     '#00FF80': 'Pastel Green',
 509     '#40FFA0': 'Light Emerald',
 510     '#80FFC0': 'Sea Foam',
 511     '#BFFFDF': 'Sea Mist',
 512     '#033D21': 'Dark Forrest',
 513     '#438059': 'Moss',
 514     '#7FA37C': 'Medium Green',
 515     '#007F40': 'Pine',
 516     '#8DAE94': 'Yellow Gray Green',
 517     '#ACC6B5': 'Aqua Lung',
 518     '#DDEBE2': 'Sea Vapor',
 519     '#00BFBF': 'Fog',
 520     '#00FFFF': 'Cyan',
 521     '#40FFFF': 'Turquoise Blue',
 522     '#80FFFF': 'Light Aqua',
 523     '#BFFFFF': 'Pale Cyan',
 524     '#033D3D': 'Dark Teal',
 525     '#347D7E': 'Gray Turquoise',
 526     '#609A9F': 'Green Blue',
 527     '#007F7F': 'Seaweed',
 528     '#96BDC4': 'Green Gray',
 529     '#B5D1D7': 'Soapstone',
 530     '#E2F1F4': 'Light Turquoise',
 531     '#0060BF': 'Summer Sky',
 532     '#0080FF': 'Sky Blue',
 533     '#40A0FF': 'Electric Blue',
 534     '#80C0FF': 'Light Azure',
 535     '#BFDFFF': 'Ice Blue',
 536     '#1B2C48': 'Navy',
 537     '#385376': 'Biscay',
 538     '#57708F': 'Dusty Blue',
 539     '#00407F': 'Sea Blue',
 540     '#7792AC': 'Sky Blue Gray',
 541     '#A8BED1': 'Morning Sky',
 542     '#DEEBF6': 'Vapor',
 543     '#0000BF': 'Deep Blue',
 544     '#0000FF': 'Blue',
 545     '#4040FF': 'Cerulean Blue',
 546     '#8080FF': 'Evening Blue',
 547     '#BFBFFF': 'Light Blue',
 548     '#212143': 'Deep Indigo',
 549     '#373E68': 'Sea Blue',
 550     '#444F75': 'Night Blue',
 551     '#00007F': 'Indigo Blue',
 552     '#585E82': 'Dockside',
 553     '#8687A4': 'Blue Gray',
 554     '#D2D1E1': 'Light Blue Gray',
 555     '#6000BF': 'Neon Violet',
 556     '#8000FF': 'Blue Violet',
 557     '#A040FF': 'Violet Purple',
 558     '#C080FF': 'Violet Dusk',
 559     '#DFBFFF': 'Pale Lavender',
 560     '#302449': 'Cool Shale',
 561     '#54466F': 'Dark Indigo',
 562     '#655A7F': 'Dark Violet',
 563     '#40007F': 'Violet',
 564     '#726284': 'Smoky Violet',
 565     '#9E8FA9': 'Slate Gray',
 566     '#DCD1DF': 'Violet White',
 567     '#BF00BF': 'Royal Violet',
 568     '#FF00FF': 'Fuchsia',
 569     '#FF40FF': 'Magenta',
 570     '#FF80FF': 'Orchid',
 571     '#FFBFFF': 'Pale Magenta',
 572     '#4A234A': 'Dark Purple',
 573     '#794A72': 'Medium Purple',
 574     '#936386': 'Cool Granite',
 575     '#7F007F': 'Purple',
 576     '#9D7292': 'Purple Moon',
 577     '#C0A0B6': 'Pale Purple',
 578     '#ECDAE5': 'Pink Cloud',
 579     '#BF005F': 'Hot Pink',
 580     '#FF007F': 'Deep Pink',
 581     '#FF409F': 'Grape',
 582     '#FF80BF': 'Electric Pink',
 583     '#FFBFDF': 'Pink',
 584     '#451528': 'Purple Red',
 585     '#823857': 'Purple Dino',
 586     '#A94A76': 'Purple Gray',
 587     '#7F003F': 'Rose',
 588     '#BC6F95': 'Antique Mauve',
 589     '#D8A5BB': 'Cool Marble',
 590     '#F7DDE9': 'Pink Granite',
 591     '#C00000': 'Apple',
 592     '#FF0000': 'Fire Truck',
 593     '#FF4040': 'Pale Red',
 594     '#FF8080': 'Salmon',
 595     '#FFC0C0': 'Warm Pink',
 596     '#441415': 'Sepia',
 597     '#82393C': 'Rust',
 598     '#AA4D4E': 'Brick',
 599     '#800000': 'Brick Red',
 600     '#BC6E6E': 'Mauve',
 601     '#D8A3A4': 'Shrimp Pink',
 602     '#F8DDDD': 'Shell Pink',
 603     '#BF5F00': 'Dark Orange',
 604     '#FF7F00': 'Orange',
 605     '#FF9F40': 'Grapefruit',
 606     '#FFBF80': 'Canteloupe',
 607     '#FFDFBF': 'Wax',
 608     '#482C1B': 'Dark Brick',
 609     '#855A40': 'Dirt',
 610     '#B27C51': 'Tan',
 611     '#7F3F00': 'Nutmeg',
 612     '#C49B71': 'Mustard',
 613     '#E1C4A8': 'Pale Tan',
 614     '#FDEEE0': 'Marble'
 615 /* }}} */
 616         },
 617         /**
 618         * @property _colorPicker
 619         * @description The HTML Element containing the colorPicker
 620         * @type HTMLElement
 621         */
 622         _colorPicker: null,
 623         /**
 624         * @property STR_COLLAPSE
 625         * @description String for Toolbar Collapse Button
 626         * @type String
 627         */
 628         STR_COLLAPSE: 'Collapse Toolbar',
 629         /**
 630         * @property STR_SPIN_LABEL
 631         * @description String for spinbutton dynamic label. Note the {VALUE} will be replaced with YAHOO.lang.substitute
 632         * @type String
 633         */
 634         STR_SPIN_LABEL: 'Spin Button with value {VALUE}. Use Control Shift Up Arrow and Control Shift Down arrow keys to increase or decrease the value.',
 635         /**
 636         * @property STR_SPIN_UP
 637         * @description String for spinbutton up
 638         * @type String
 639         */
 640         STR_SPIN_UP: 'Click to increase the value of this input',
 641         /**
 642         * @property STR_SPIN_DOWN
 643         * @description String for spinbutton down
 644         * @type String
 645         */
 646         STR_SPIN_DOWN: 'Click to decrease the value of this input',
 647         /**
 648         * @property _titlebar
 649         * @description Object reference to the titlebar
 650         * @type HTMLElement
 651         */
 652         _titlebar: null,
 653         /**
 654         * @property browser
 655         * @description Standard browser detection
 656         * @type Object
 657         */
 658         browser: YAHOO.env.ua,
 659         /**
 660         * @protected
 661         * @property _buttonList
 662         * @description Internal property list of current buttons in the toolbar
 663         * @type Array
 664         */
 665         _buttonList: null,
 666         /**
 667         * @protected
 668         * @property _buttonGroupList
 669         * @description Internal property list of current button groups in the toolbar
 670         * @type Array
 671         */
 672         _buttonGroupList: null,
 673         /**
 674         * @protected
 675         * @property _sep
 676         * @description Internal reference to the separator HTML Element for cloning
 677         * @type HTMLElement
 678         */
 679         _sep: null,
 680         /**
 681         * @protected
 682         * @property _sepCount
 683         * @description Internal refernce for counting separators, so we can give them a useful class name for styling
 684         * @type Number
 685         */
 686         _sepCount: null,
 687         /**
 688         * @protected
 689         * @property draghandle
 690         * @type HTMLElement
 691         */
 692         _dragHandle: null,
 693         /**
 694         * @protected
 695         * @property _toolbarConfigs
 696         * @type Object
 697         */
 698         _toolbarConfigs: {
 699             renderer: true
 700         },
 701         /**
 702         * @protected
 703         * @property CLASS_CONTAINER
 704         * @description Default CSS class to apply to the toolbar container element
 705         * @type String
 706         */
 707         CLASS_CONTAINER: 'yui-toolbar-container',
 708         /**
 709         * @protected
 710         * @property CLASS_DRAGHANDLE
 711         * @description Default CSS class to apply to the toolbar's drag handle element
 712         * @type String
 713         */
 714         CLASS_DRAGHANDLE: 'yui-toolbar-draghandle',
 715         /**
 716         * @protected
 717         * @property CLASS_SEPARATOR
 718         * @description Default CSS class to apply to all separators in the toolbar
 719         * @type String
 720         */
 721         CLASS_SEPARATOR: 'yui-toolbar-separator',
 722         /**
 723         * @protected
 724         * @property CLASS_DISABLED
 725         * @description Default CSS class to apply when the toolbar is disabled
 726         * @type String
 727         */
 728         CLASS_DISABLED: 'yui-toolbar-disabled',
 729         /**
 730         * @protected
 731         * @property CLASS_PREFIX
 732         * @description Default prefix for dynamically created class names
 733         * @type String
 734         */
 735         CLASS_PREFIX: 'yui-toolbar',
 736         /**
 737         * @method init
 738         * @description The Toolbar class's initialization method
 739         */
 740         init: function(p_oElement, p_oAttributes) {
 741             YAHOO.widget.Toolbar.superclass.init.call(this, p_oElement, p_oAttributes);
 742
 743         },
 744         /**
 745         * @method initAttributes
 746         * @description Initializes all of the configuration attributes used to create
 747         * the toolbar.
 748         * @param {Object} attr Object literal specifying a set of
 749         * configuration attributes used to create the toolbar.
 750         */
 751         initAttributes: function(attr) {
 752             YAHOO.widget.Toolbar.superclass.initAttributes.call(this, attr);
 753             this.addClass(this.CLASS_CONTAINER);
 754
 755             /**
 756             * @attribute buttonType
 757             * @description The buttonType to use (advanced or basic)
 758             * @type String
 759             */
 760             this.setAttributeConfig('buttonType', {
 761                 value: attr.buttonType || 'basic',
 762                 writeOnce: true,
 763                 validator: function(type) {
 764                     switch (type) {
 765                         case 'advanced':
 766                         case 'basic':
 767                             return true;
 768                     }
 769                     return false;
 770                 },
 771                 method: function(type) {
 772                     if (type == 'advanced') {
 773                         if (YAHOO.widget.Button) {
 774                             this.buttonType = YAHOO.widget.ToolbarButtonAdvanced;
 775                         } else {
 776                             YAHOO.log('Can not find YAHOO.widget.Button', 'error', 'Toolbar');
 777                             this.buttonType = YAHOO.widget.ToolbarButton;
 778                         }
 779                     } else {
 780                         this.buttonType = YAHOO.widget.ToolbarButton;
 781                     }
 782                 }
 783             });
 784
 785
 786             /**
 787             * @attribute buttons
 788             * @description Object specifying the buttons to include in the toolbar
 789             * Example:
 790             * <code><pre>
 791             * {
 792             *   { id: 'b3', type: 'button', label: 'Underline', value: 'underline' },
 793             *   { type: 'separator' },
 794             *   { id: 'b4', type: 'menu', label: 'Align', value: 'align',
 795             *       menu: [
 796             *           { text: "Left", value: 'alignleft' },
 797             *           { text: "Center", value: 'aligncenter' },
 798             *           { text: "Right", value: 'alignright' }
 799             *       ]
 800             *   }
 801             * }
 802             * </pre></code>
 803             * @type Array
 804             */
 805
 806             this.setAttributeConfig('buttons', {
 807                 value: [],
 808                 writeOnce: true,
 809                 method: function(data) {
 810                     for (var i in data) {
 811                         if (Lang.hasOwnProperty(data, i)) {
 812                             if (data[i].type == 'separator') {
 813                                 this.addSeparator();
 814                             } else if (data[i].group !== undefined) {
 815                                 this.addButtonGroup(data[i]);
 816                             } else {
 817                                 this.addButton(data[i]);
 818                             }
 819                         }
 820                     }
 821                 }
 822             });
 823
 824             /**
 825             * @attribute disabled
 826             * @description Boolean indicating if the toolbar should be disabled. It will also disable the draggable attribute if it is on.
 827             * @default false
 828             * @type Boolean
 829             */
 830             this.setAttributeConfig('disabled', {
 831                 value: false,
 832                 method: function(disabled) {
 833                     if (this.get('disabled') === disabled) {
 834                         return false;
 835                     }
 836                     if (disabled) {
 837                         this.addClass(this.CLASS_DISABLED);
 838                         this.set('draggable', false);
 839                         this.disableAllButtons();
 840                     } else {
 841                         this.removeClass(this.CLASS_DISABLED);
 842                         if (this._configs.draggable._initialConfig.value) {
 843                             //Draggable by default, set it back
 844                             this.set('draggable', true);
 845                         }
 846                         this.resetAllButtons();
 847                     }
 848                 }
 849             });
 850
 851             /**
 852             * @config cont
 853             * @description The container for the toolbar.
 854             * @type HTMLElement
 855             */
 856             this.setAttributeConfig('cont', {
 857                 value: attr.cont,
 858                 readOnly: true
 859             });
 860
 861
 862             /**
 863             * @attribute grouplabels
 864             * @description Boolean indicating if the toolbar should show the group label's text string.
 865             * @default true
 866             * @type Boolean
 867             */
 868             this.setAttributeConfig('grouplabels', {
 869                 value: ((attr.grouplabels === false) ? false : true),
 870                 method: function(grouplabels) {
 871                     if (grouplabels) {
 872                         Dom.removeClass(this.get('cont'), (this.CLASS_PREFIX + '-nogrouplabels'));
 873                     } else {
 874                         Dom.addClass(this.get('cont'), (this.CLASS_PREFIX + '-nogrouplabels'));
 875                     }
 876                 }
 877             });
 878             /**
 879             * @attribute titlebar
 880             * @description Boolean indicating if the toolbar should have a titlebar. If
 881             * passed a string, it will use that as the titlebar text
 882             * @default false
 883             * @type Boolean or String
 884             */
 885             this.setAttributeConfig('titlebar', {
 886                 value: false,
 887                 method: function(titlebar) {
 888                     if (titlebar) {
 889                         if (this._titlebar && this._titlebar.parentNode) {
 890                             this._titlebar.parentNode.removeChild(this._titlebar);
 891                         }
 892                         this._titlebar = document.createElement('DIV');
 893                         this._titlebar.tabIndex = '-1';
 894                         Event.on(this._titlebar, 'focus', function() {
 895                             this._handleFocus();
 896                         }, this, true);
 897                         Dom.addClass(this._titlebar, this.CLASS_PREFIX + '-titlebar');
 898                         if (Lang.isString(titlebar)) {
 899                             var h2 = document.createElement('h2');
 900                             h2.tabIndex = '-1';
 901                             h2.innerHTML = '<a href="#" tabIndex="0">' + titlebar + '</a>';
 902                             this._titlebar.appendChild(h2);
 903                             Event.on(h2.firstChild, 'click', function(ev) {
 904                                 Event.stopEvent(ev);
 905                             });
 906                             Event.on([h2, h2.firstChild], 'focus', function() {
 907                                 this._handleFocus();
 908                             }, this, true);
 909                         }
 910                         if (this.get('firstChild')) {
 911                             this.insertBefore(this._titlebar, this.get('firstChild'));
 912                         } else {
 913                             this.appendChild(this._titlebar);
 914                         }
 915                         if (this.get('collapse')) {
 916                             this.set('collapse', true);
 917                         }
 918                     } else if (this._titlebar) {
 919                         if (this._titlebar && this._titlebar.parentNode) {
 920                             this._titlebar.parentNode.removeChild(this._titlebar);
 921                         }
 922                     }
 923                 }
 924             });
 925
 926
 927             /**
 928             * @attribute collapse
 929             * @description Boolean indicating if the the titlebar should have a collapse button.
 930             * The collapse button will not remove the toolbar, it will minimize it to the titlebar
 931             * @default false
 932             * @type Boolean
 933             */
 934             this.setAttributeConfig('collapse', {
 935                 value: false,
 936                 method: function(collapse) {
 937                     if (this._titlebar) {
 938                         var collapseEl = null;
 939                         var el = Dom.getElementsByClassName('collapse', 'span', this._titlebar);
 940                         if (collapse) {
 941                             if (el.length > 0) {
 942                                 //There is already a collapse button
 943                                 return true;
 944                             }
 945                             collapseEl = document.createElement('SPAN');
 946                             collapseEl.innerHTML = 'X';
 947                             collapseEl.title = this.STR_COLLAPSE;
 948
 949                             Dom.addClass(collapseEl, 'collapse');
 950                             this._titlebar.appendChild(collapseEl);
 951                             Event.addListener(collapseEl, 'click', function() {
 952                                 if (Dom.hasClass(this.get('cont').parentNode, 'yui-toolbar-container-collapsed')) {
 953                                     this.collapse(false); //Expand Toolbar
 954                                 } else {
 955                                     this.collapse(); //Collapse Toolbar
 956                                 }
 957                             }, this, true);
 958                         } else {
 959                             collapseEl = Dom.getElementsByClassName('collapse', 'span', this._titlebar);
 960                             if (collapseEl[0]) {
 961                                 if (Dom.hasClass(this.get('cont').parentNode, 'yui-toolbar-container-collapsed')) {
 962                                     //We are closed, reopen the titlebar..
 963                                     this.collapse(false); //Expand Toolbar
 964                                 }
 965                                 collapseEl[0].parentNode.removeChild(collapseEl[0]);
 966                             }
 967                         }
 968                     }
 969                 }
 970             });
 971
 972             /**
 973             * @attribute draggable
 974             * @description Boolean indicating if the toolbar should be draggable.
 975             * @default false
 976             * @type Boolean
 977             */
 978
 979             this.setAttributeConfig('draggable', {
 980                 value: (attr.draggable || false),
 981                 method: function(draggable) {
 982                     if (draggable && !this.get('titlebar')) {
 983                         YAHOO.log('Dragging enabled', 'info', 'Toolbar');
 984                         if (!this._dragHandle) {
 985                             this._dragHandle = document.createElement('SPAN');
 986                             this._dragHandle.innerHTML = '|';
 987                             this._dragHandle.setAttribute('title', 'Click to drag the toolbar');
 988                             this._dragHandle.id = this.get('id') + '_draghandle';
 989                             Dom.addClass(this._dragHandle, this.CLASS_DRAGHANDLE);
 990                             if (this.get('cont').hasChildNodes()) {
 991                                 this.get('cont').insertBefore(this._dragHandle, this.get('cont').firstChild);
 992                             } else {
 993                                 this.get('cont').appendChild(this._dragHandle);
 994                             }
 995                             this.dd = new YAHOO.util.DD(this.get('id'));
 996                             this.dd.setHandleElId(this._dragHandle.id);
 997
 998                         }
 999                     } else {
1000                         YAHOO.log('Dragging disabled', 'info', 'Toolbar');
1001                         if (this._dragHandle) {
1002                             this._dragHandle.parentNode.removeChild(this._dragHandle);
1003                             this._dragHandle = null;
1004                             this.dd = null;
1005                         }
1006                     }
1007                     if (this._titlebar) {
1008                         if (draggable) {
1009                             this.dd = new YAHOO.util.DD(this.get('id'));
1010                             this.dd.setHandleElId(this._titlebar);
1011                             Dom.addClass(this._titlebar, 'draggable');
1012                         } else {
1013                             Dom.removeClass(this._titlebar, 'draggable');
1014                             if (this.dd) {
1015                                 this.dd.unreg();
1016                                 this.dd = null;
1017                             }
1018                         }
1019                     }
1020                 },
1021                 validator: function(value) {
1022                     var ret = true;
1023                     if (!YAHOO.util.DD) {
1024                         ret = false;
1025                     }
1026                     return ret;
1027                 }
1028             });
1029
1030         },
1031         /**
1032         * @method addButtonGroup
1033         * @description Add a new button group to the toolbar. (uses addButton)
1034         * @param {Object} oGroup Object literal reference to the Groups Config (contains an array of button configs as well as the group label)
1035         */
1036         addButtonGroup: function(oGroup) {
1037             if (!this.get('element')) {
1038                 this._queue[this._queue.length] = ['addButtonGroup', arguments];
1039                 return false;
1040             }
1041
1042             if (!this.hasClass(this.CLASS_PREFIX + '-grouped')) {
1043                 this.addClass(this.CLASS_PREFIX + '-grouped');
1044             }
1045             var div = document.createElement('DIV');
1046             Dom.addClass(div, this.CLASS_PREFIX + '-group');
1047             Dom.addClass(div, this.CLASS_PREFIX + '-group-' + oGroup.group);
1048             if (oGroup.label) {
1049                 var label = document.createElement('h3');
1050                 label.innerHTML = oGroup.label;
1051                 div.appendChild(label);
1052             }
1053             if (!this.get('grouplabels')) {
1054                 Dom.addClass(this.get('cont'), this.CLASS_PREFIX, '-nogrouplabels');
1055             }
1056
1057             this.get('cont').appendChild(div);
1058
1059             //For accessibility, let's put all of the group buttons in an Unordered List
1060             var ul = document.createElement('ul');
1061             div.appendChild(ul);
1062
1063             if (!this._buttonGroupList) {
1064                 this._buttonGroupList = {};
1065             }
1066
1067             this._buttonGroupList[oGroup.group] = ul;
1068
1069             for (var i = 0; i < oGroup.buttons.length; i++) {
1070                 var li = document.createElement('li');
1071                 li.className = this.CLASS_PREFIX + '-groupitem';
1072                 ul.appendChild(li);
1073                 if ((oGroup.buttons[i].type !== undefined) && oGroup.buttons[i].type == 'separator') {
1074                     this.addSeparator(li);
1075                 } else {
1076                     oGroup.buttons[i].container = li;
1077                     this.addButton(oGroup.buttons[i]);
1078                 }
1079             }
1080         },
1081         /**
1082         * @method addButtonToGroup
1083         * @description Add a new button to a toolbar group. Buttons supported:
1084         *   push, split, menu, select, color, spin
1085         * @param {Object} oButton Object literal reference to the Button's Config
1086         * @param {String} group The Group identifier passed into the initial config
1087         * @param {HTMLElement} after Optional HTML element to insert this button after in the DOM.
1088         */
1089         addButtonToGroup: function(oButton, group, after) {
1090             var groupCont = this._buttonGroupList[group];
1091             var li = document.createElement('li');
1092             li.className = this.CLASS_PREFIX + '-groupitem';
1093             oButton.container = li;
1094             this.addButton(oButton, after);
1095             groupCont.appendChild(li);
1096         },
1097         /**
1098         * @method addButton
1099         * @description Add a new button to the toolbar. Buttons supported:
1100         *   push, split, menu, select, color, spin
1101         * @param {Object} oButton Object literal reference to the Button's Config
1102         * @param {HTMLElement} after Optional HTML element to insert this button after in the DOM.
1103         */
1104         addButton: function(oButton, after) {
1105             if (!this.get('element')) {
1106                 this._queue[this._queue.length] = ['addButton', arguments];
1107                 return false;
1108             }
1109             if (!this._buttonList) {
1110                 this._buttonList = [];
1111             }
1112             YAHOO.log('Adding button of type: ' + oButton.type, 'info', 'Toolbar');
1113             if (!oButton.container) {
1114                 oButton.container = this.get('cont');
1115             }
1116
1117             if ((oButton.type == 'menu') || (oButton.type == 'split') || (oButton.type == 'select')) {
1118                 if (Lang.isArray(oButton.menu)) {
1119                     for (var i in oButton.menu) {
1120                         if (Lang.hasOwnProperty(oButton.menu, i)) {
1121                             var funcObject = {
1122                                 fn: function(ev, x, oMenu) {
1123                                     if (!oButton.menucmd) {
1124                                         oButton.menucmd = oButton.value;
1125                                     }
1126                                     oButton.value = ((oMenu.value) ? oMenu.value : oMenu._oText.nodeValue);
1127                                 },
1128                                 scope: this
1129                             };
1130                             oButton.menu[i].onclick = funcObject;
1131                         }
1132                     }
1133                 }
1134             }
1135             var _oButton = {}, skip = false;
1136             for (var o in oButton) {
1137                 if (Lang.hasOwnProperty(oButton, o)) {
1138                     if (!this._toolbarConfigs[o]) {
1139                         _oButton[o] = oButton[o];
1140                     }
1141                 }
1142             }
1143             if (oButton.type == 'select') {
1144                 _oButton.type = 'menu';
1145             }
1146             if (oButton.type == 'spin') {
1147                 _oButton.type = 'push';
1148             }
1149             if (_oButton.type == 'color') {
1150                 if (YAHOO.widget.Overlay) {
1151                     _oButton = this._makeColorButton(_oButton);
1152                 } else {
1153                     skip = true;
1154                 }
1155             }
1156             if (_oButton.menu) {
1157                 if ((YAHOO.widget.Overlay) && (oButton.menu instanceof YAHOO.widget.Overlay)) {
1158                     oButton.menu.showEvent.subscribe(function() {
1159                         this._button = _oButton;
1160                     });
1161                 } else {
1162                     for (var m = 0; m < _oButton.menu.length; m++) {
1163                         if (!_oButton.menu[m].value) {
1164                             _oButton.menu[m].value = _oButton.menu[m].text;
1165                         }
1166                     }
1167                     if (this.browser.webkit) {
1168                         _oButton.focusmenu = false;
1169                     }
1170                 }
1171             }
1172             if (skip) {
1173                 oButton = false;
1174             } else {
1175                 //Add to .get('buttons') manually
1176                 this._configs.buttons.value[this._configs.buttons.value.length] = oButton;
1177
1178                 var tmp = new this.buttonType(_oButton);
1179                 tmp.get('element').tabIndex = '-1';
1180                 tmp.get('element').setAttribute('role', 'button');
1181                 tmp._selected = true;
1182
1183                 if (this.get('disabled')) {
1184                     //Toolbar is disabled, disable the new button too!
1185                     tmp.set('disabled', true);
1186                 }
1187                 if (!oButton.id) {
1188                     oButton.id = tmp.get('id');
1189                 }
1190                 YAHOO.log('Button created (' + oButton.type + ')', 'info', 'Toolbar');
1191
1192                 if (after) {
1193                     var el = tmp.get('element');
1194                     var nextSib = null;
1195                     if (after.get) {
1196                         nextSib = after.get('element').nextSibling;
1197                     } else if (after.nextSibling) {
1198                         nextSib = after.nextSibling;
1199                     }
1200                     if (nextSib) {
1201                         nextSib.parentNode.insertBefore(el, nextSib);
1202                     }
1203                 }
1204                 tmp.addClass(this.CLASS_PREFIX + '-' + tmp.get('value'));
1205
1206                 var icon = document.createElement('span');
1207                 icon.className = this.CLASS_PREFIX + '-icon';
1208                 tmp.get('element').insertBefore(icon, tmp.get('firstChild'));
1209                 if (tmp._button.tagName.toLowerCase() == 'button') {
1210                     tmp.get('element').setAttribute('unselectable', 'on');
1211                     //Replace the Button HTML Element with an a href if it exists
1212                     var a = document.createElement('a');
1213                     a.innerHTML = tmp._button.innerHTML;
1214                     a.href = '#';
1215                     a.tabIndex = '-1';
1216                     Event.on(a, 'click', function(ev) {
1217                         Event.stopEvent(ev);
1218                     });
1219                     tmp._button.parentNode.replaceChild(a, tmp._button);
1220                     tmp._button = a;
1221                 }
1222
1223                 if (oButton.type == 'select') {
1224                     if (tmp._button.tagName.toLowerCase() == 'select') {
1225                         icon.parentNode.removeChild(icon);
1226                         var iel = tmp._button;
1227                         var parEl = tmp.get('element');
1228                         parEl.parentNode.replaceChild(iel, parEl);
1229                     } else {
1230                         //Don't put a class on it if it's a real select element
1231                         tmp.addClass(this.CLASS_PREFIX + '-select');
1232                     }
1233                 }
1234                 if (oButton.type == 'spin') {
1235                     if (!Lang.isArray(oButton.range)) {
1236                         oButton.range = [ 10, 100 ];
1237                     }
1238                     this._makeSpinButton(tmp, oButton);
1239                 }
1240                 tmp.get('element').setAttribute('title', tmp.get('label'));
1241                 if (oButton.type != 'spin') {
1242                     if ((YAHOO.widget.Overlay) && (_oButton.menu instanceof YAHOO.widget.Overlay)) {
1243                         var showPicker = function(ev) {
1244                             var exec = true;
1245                             if (ev.keyCode && (ev.keyCode == 9)) {
1246                                 exec = false;
1247                             }
1248                             if (exec) {
1249                                 if (this._colorPicker) {
1250                                     this._colorPicker._button = oButton.value;
1251                                 }
1252                                 var menuEL = tmp.getMenu().element;
1253                                 if (Dom.getStyle(menuEL, 'visibility') == 'hidden') {
1254                                     tmp.getMenu().show();
1255                                 } else {
1256                                     tmp.getMenu().hide();
1257                                 }
1258                             }
1259                             YAHOO.util.Event.stopEvent(ev);
1260                         };
1261                         tmp.on('mousedown', showPicker, oButton, this);
1262                         tmp.on('keydown', showPicker, oButton, this);
1263
1264                     } else if ((oButton.type != 'menu') && (oButton.type != 'select')) {
1265                         tmp.on('keypress', this._buttonClick, oButton, this);
1266                         tmp.on('mousedown', function(ev) {
1267                             YAHOO.util.Event.stopEvent(ev);
1268                             this._buttonClick(ev, oButton);
1269                         }, oButton, this);
1270                         tmp.on('click', function(ev) {
1271                             YAHOO.util.Event.stopEvent(ev);
1272                         });
1273                     } else {
1274                         //Stop the mousedown event so we can trap the selection in the editor!
1275                         tmp.on('mousedown', function(ev) {
1276                             YAHOO.util.Event.stopEvent(ev);
1277                         });
1278                         tmp.on('click', function(ev) {
1279                             YAHOO.util.Event.stopEvent(ev);
1280                         });
1281                         tmp.on('change', function(ev) {
1282                             if (!oButton.menucmd) {
1283                                 oButton.menucmd = oButton.value;
1284                             }
1285                             oButton.value = ev.value;
1286                             this._buttonClick(ev, oButton);
1287                         }, this, true);
1288
1289                         var self = this;
1290                         //Hijack the mousedown event in the menu and make it fire a button click..
1291                         tmp.on('appendTo', function() {
1292                             var tmp = this;
1293                             if (tmp.getMenu() && tmp.getMenu().mouseDownEvent) {
1294                                 tmp.getMenu().mouseDownEvent.subscribe(function(ev, args) {
1295                                     YAHOO.log('mouseDownEvent', 'warn', 'Toolbar');
1296                                     var oMenu = args[1];
1297                                     YAHOO.util.Event.stopEvent(args[0]);
1298                                     tmp._onMenuClick(args[0], tmp);
1299                                     if (!oButton.menucmd) {
1300                                         oButton.menucmd = oButton.value;
1301                                     }
1302                                     oButton.value = ((oMenu.value) ? oMenu.value : oMenu._oText.nodeValue);
1303                                     self._buttonClick.call(self, args[1], oButton);
1304                                     tmp._hideMenu();
1305                                     return false;
1306                                 });
1307                                 tmp.getMenu().clickEvent.subscribe(function(ev, args) {
1308                                     YAHOO.log('clickEvent', 'warn', 'Toolbar');
1309                                     YAHOO.util.Event.stopEvent(args[0]);
1310                                 });
1311                                 tmp.getMenu().mouseUpEvent.subscribe(function(ev, args) {
1312                                     YAHOO.log('mouseUpEvent', 'warn', 'Toolbar');
1313                                     YAHOO.util.Event.stopEvent(args[0]);
1314                                 });
1315                             }
1316                         });
1317
1318                     }
1319                 } else {
1320                     //Stop the mousedown event so we can trap the selection in the editor!
1321                     tmp.on('mousedown', function(ev) {
1322                         YAHOO.util.Event.stopEvent(ev);
1323                     });
1324                     tmp.on('click', function(ev) {
1325                         YAHOO.util.Event.stopEvent(ev);
1326                     });
1327                 }
1328                 if (this.browser.ie) {
1329                     /*
1330                     //Add a couple of new events for IE
1331                     tmp.DOM_EVENTS.focusin = true;
1332                     tmp.DOM_EVENTS.focusout = true;
1333
1334                     //Stop them so we don't loose focus in the Editor
1335                     tmp.on('focusin', function(ev) {
1336                         YAHOO.util.Event.stopEvent(ev);
1337                     }, oButton, this);
1338
1339                     tmp.on('focusout', function(ev) {
1340                         YAHOO.util.Event.stopEvent(ev);
1341                     }, oButton, this);
1342                     tmp.on('click', function(ev) {
1343                         YAHOO.util.Event.stopEvent(ev);
1344                     }, oButton, this);
1345                     */
1346                 }
1347                 if (this.browser.webkit) {
1348                     //This will keep the document from gaining focus and the editor from loosing it..
1349                     //Forcefully remove the focus calls in button!
1350                     tmp.hasFocus = function() {
1351                         return true;
1352                     };
1353                 }
1354                 this._buttonList[this._buttonList.length] = tmp;
1355                 if ((oButton.type == 'menu') || (oButton.type == 'split') || (oButton.type == 'select')) {
1356                     if (Lang.isArray(oButton.menu)) {
1357                         YAHOO.log('Button type is (' + oButton.type + '), doing extra renderer work.', 'info', 'Toolbar');
1358                         var menu = tmp.getMenu();
1359                         if (menu && menu.renderEvent) {
1360                             menu.renderEvent.subscribe(this._addMenuClasses, tmp);
1361                             if (oButton.renderer) {
1362                                 menu.renderEvent.subscribe(oButton.renderer, tmp);
1363                             }
1364                         }
1365                     }
1366                 }
1367             }
1368             return oButton;
1369         },
1370         /**
1371         * @method addSeparator
1372         * @description Add a new button separator to the toolbar.
1373         * @param {HTMLElement} cont Optional HTML element to insert this button into.
1374         * @param {HTMLElement} after Optional HTML element to insert this button after in the DOM.
1375         */
1376         addSeparator: function(cont, after) {
1377             if (!this.get('element')) {
1378                 this._queue[this._queue.length] = ['addSeparator', arguments];
1379                 return false;
1380             }
1381             var sepCont = ((cont) ? cont : this.get('cont'));
1382             if (!this.get('element')) {
1383                 this._queue[this._queue.length] = ['addSeparator', arguments];
1384                 return false;
1385             }
1386             if (this._sepCount === null) {
1387                 this._sepCount = 0;
1388             }
1389             if (!this._sep) {
1390                 YAHOO.log('Separator does not yet exist, creating', 'info', 'Toolbar');
1391                 this._sep = document.createElement('SPAN');
1392                 Dom.addClass(this._sep, this.CLASS_SEPARATOR);
1393                 this._sep.innerHTML = '|';
1394             }
1395             YAHOO.log('Separator does exist, cloning', 'info', 'Toolbar');
1396             var _sep = this._sep.cloneNode(true);
1397             this._sepCount++;
1398             Dom.addClass(_sep, this.CLASS_SEPARATOR + '-' + this._sepCount);
1399             if (after) {
1400                 var nextSib = null;
1401                 if (after.get) {
1402                     nextSib = after.get('element').nextSibling;
1403                 } else if (after.nextSibling) {
1404                     nextSib = after.nextSibling;
1405                 } else {
1406                     nextSib = after;
1407                 }
1408                 if (nextSib) {
1409                     if (nextSib == after) {
1410                         nextSib.parentNode.appendChild(_sep);
1411                     } else {
1412                         nextSib.parentNode.insertBefore(_sep, nextSib);
1413                     }
1414                 }
1415             } else {
1416                 sepCont.appendChild(_sep);
1417             }
1418             return _sep;
1419         },
1420         /**
1421         * @method _createColorPicker
1422         * @private
1423         * @description Creates the core DOM reference to the color picker menu item.
1424         * @param {String} id the id of the toolbar to prefix this DOM container with.
1425         */
1426         _createColorPicker: function(id) {
1427             if (Dom.get(id + '_colors')) {
1428                Dom.get(id + '_colors').parentNode.removeChild(Dom.get(id + '_colors'));
1429             }
1430             var picker = document.createElement('div');
1431             picker.className = 'yui-toolbar-colors';
1432             picker.id = id + '_colors';
1433             picker.style.display = 'none';
1434             Event.on(window, 'load', function() {
1435                 document.body.appendChild(picker);
1436             }, this, true);
1437
1438             this._colorPicker = picker;
1439
1440             var html = '';
1441             for (var i in this._colorData) {
1442                 if (Lang.hasOwnProperty(this._colorData, i)) {
1443                     html += '<a style="background-color: ' + i + '" href="#">' + i.replace('#', '') + '</a>';
1444                 }
1445             }
1446             html += '<span><em>X</em><strong></strong></span>';
1447             window.setTimeout(function() {
1448                 picker.innerHTML = html;
1449             }, 0);
1450
1451             Event.on(picker, 'mouseover', function(ev) {
1452                 var picker = this._colorPicker;
1453                 var em = picker.getElementsByTagName('em')[0];
1454                 var strong = picker.getElementsByTagName('strong')[0];
1455                 var tar = Event.getTarget(ev);
1456                 if (tar.tagName.toLowerCase() == 'a') {
1457                     em.style.backgroundColor = tar.style.backgroundColor;
1458                     strong.innerHTML = this._colorData['#' + tar.innerHTML] + '<br>' + tar.innerHTML;
1459                 }
1460             }, this, true);
1461             Event.on(picker, 'focus', function(ev) {
1462                 Event.stopEvent(ev);
1463             });
1464             Event.on(picker, 'click', function(ev) {
1465                 Event.stopEvent(ev);
1466             });
1467             Event.on(picker, 'mousedown', function(ev) {
1468                 Event.stopEvent(ev);
1469                 var tar = Event.getTarget(ev);
1470                 if (tar.tagName.toLowerCase() == 'a') {
1471                     var retVal = this.fireEvent('colorPickerClicked', { type: 'colorPickerClicked', target: this, button: this._colorPicker._button, color: tar.innerHTML, colorName: this._colorData['#' + tar.innerHTML] } );
1472                     if (retVal !== false) {
1473                         var info = {
1474                             color: tar.innerHTML,
1475                             colorName: this._colorData['#' + tar.innerHTML],
1476                             value: this._colorPicker._button
1477                         };
1478
1479                         this.fireEvent('buttonClick', { type: 'buttonClick', target: this.get('element'), button: info });
1480                     }
1481                     this.getButtonByValue(this._colorPicker._button).getMenu().hide();
1482                 }
1483             }, this, true);
1484         },
1485         /**
1486         * @method _resetColorPicker
1487         * @private
1488         * @description Clears the currently selected color or mouseover color in the color picker.
1489         */
1490         _resetColorPicker: function() {
1491             var em = this._colorPicker.getElementsByTagName('em')[0];
1492             var strong = this._colorPicker.getElementsByTagName('strong')[0];
1493             em.style.backgroundColor = 'transparent';
1494             strong.innerHTML = '';
1495         },
1496         /**
1497         * @method _makeColorButton
1498         * @private
1499         * @description Called to turn a "color" button into a menu button with an Overlay for the menu.
1500         * @param {Object} _oButton <a href="YAHOO.widget.ToolbarButton.html">YAHOO.widget.ToolbarButton</a> reference
1501         */
1502         _makeColorButton: function(_oButton) {
1503             if (!this._colorPicker) {
1504                 this._createColorPicker(this.get('id'));
1505             }
1506             _oButton.type = 'color';
1507             _oButton.menu = new YAHOO.widget.Overlay(this.get('id') + '_' + _oButton.value + '_menu', { visible: false, position: 'absolute', iframe: true });
1508             _oButton.menu.setBody('');
1509             _oButton.menu.render(this.get('cont'));
1510             Dom.addClass(_oButton.menu.element, 'yui-button-menu');
1511             Dom.addClass(_oButton.menu.element, 'yui-color-button-menu');
1512             _oButton.menu.beforeShowEvent.subscribe(function() {
1513                 _oButton.menu.cfg.setProperty('zindex', 5); //Re Adjust the overlays zIndex.. not sure why.
1514                 _oButton.menu.cfg.setProperty('context', [this.getButtonById(_oButton.id).get('element'), 'tl', 'bl']); //Re Adjust the overlay.. not sure why.
1515                 //Move the DOM reference of the color picker to the Overlay that we are about to show.
1516                 this._resetColorPicker();
1517                 var _p = this._colorPicker;
1518                 if (_p.parentNode) {
1519                     _p.parentNode.removeChild(_p);
1520                 }
1521                 _oButton.menu.setBody('');
1522                 _oButton.menu.appendToBody(_p);
1523                 this._colorPicker.style.display = 'block';
1524             }, this, true);
1525             return _oButton;
1526         },
1527         /**
1528         * @private
1529         * @method _makeSpinButton
1530         * @description Create a button similar to an OS Spin button.. It has an up/down arrow combo to scroll through a range of int values.
1531         * @param {Object} _button <a href="YAHOO.widget.ToolbarButton.html">YAHOO.widget.ToolbarButton</a> reference
1532         * @param {Object} oButton Object literal containing the buttons initial config
1533         */
1534         _makeSpinButton: function(_button, oButton) {
1535             _button.addClass(this.CLASS_PREFIX + '-spinbutton');
1536             var self = this,
1537                 _par = _button._button.parentNode.parentNode, //parentNode of Button Element for appending child
1538                 range = oButton.range,
1539                 _b1 = document.createElement('a'),
1540                 _b2 = document.createElement('a');
1541                 _b1.href = '#';
1542                 _b2.href = '#';
1543                 _b1.tabIndex = '-1';
1544                 _b2.tabIndex = '-1';
1545
1546             //Setup the up and down arrows
1547             _b1.className = 'up';
1548             _b1.title = this.STR_SPIN_UP;
1549             _b1.innerHTML = this.STR_SPIN_UP;
1550             _b2.className = 'down';
1551             _b2.title = this.STR_SPIN_DOWN;
1552             _b2.innerHTML = this.STR_SPIN_DOWN;
1553
1554             //Append them to the container
1555             _par.appendChild(_b1);
1556             _par.appendChild(_b2);
1557
1558             var label = YAHOO.lang.substitute(this.STR_SPIN_LABEL, { VALUE: _button.get('label') });
1559             _button.set('title', label);
1560
1561             var cleanVal = function(value) {
1562                 value = ((value < range[0]) ? range[0] : value);
1563                 value = ((value > range[1]) ? range[1] : value);
1564                 return value;
1565             };
1566
1567             var br = this.browser;
1568             var tbar = false;
1569             var strLabel = this.STR_SPIN_LABEL;
1570             if (this._titlebar && this._titlebar.firstChild) {
1571                 tbar = this._titlebar.firstChild;
1572             }
1573
1574             var _intUp = function(ev) {
1575                 YAHOO.util.Event.stopEvent(ev);
1576                 if (!_button.get('disabled') && (ev.keyCode != 9)) {
1577                     var value = parseInt(_button.get('label'), 10);
1578                     value++;
1579                     value = cleanVal(value);
1580                     _button.set('label', ''+value);
1581                     var label = YAHOO.lang.substitute(strLabel, { VALUE: _button.get('label') });
1582                     _button.set('title', label);
1583                     if (!br.webkit && tbar) {
1584                         //tbar.focus(); //We do this for accessibility, on the re-focus of the element, a screen reader will re-read the title that was just changed
1585                         //_button.focus();
1586                     }
1587                     self._buttonClick(ev, oButton);
1588                 }
1589             };
1590
1591             var _intDown = function(ev) {
1592                 YAHOO.util.Event.stopEvent(ev);
1593                 if (!_button.get('disabled') && (ev.keyCode != 9)) {
1594                     var value = parseInt(_button.get('label'), 10);
1595                     value--;
1596                     value = cleanVal(value);
1597
1598                     _button.set('label', ''+value);
1599                     var label = YAHOO.lang.substitute(strLabel, { VALUE: _button.get('label') });
1600                     _button.set('title', label);
1601                     if (!br.webkit && tbar) {
1602                         //tbar.focus(); //We do this for accessibility, on the re-focus of the element, a screen reader will re-read the title that was just changed
1603                         //_button.focus();
1604                     }
1605                     self._buttonClick(ev, oButton);
1606                 }
1607             };
1608
1609             var _intKeyUp = function(ev) {
1610                 if (ev.keyCode == 38) {
1611                     _intUp(ev);
1612                 } else if (ev.keyCode == 40) {
1613                     _intDown(ev);
1614                 } else if (ev.keyCode == 107 && ev.shiftKey) {  //Plus Key
1615                     _intUp(ev);
1616                 } else if (ev.keyCode == 109 && ev.shiftKey) {  //Minus Key
1617                     _intDown(ev);
1618                 }
1619             };
1620
1621             //Handle arrow keys..
1622             _button.on('keydown', _intKeyUp, this, true);
1623
1624             //Listen for the click on the up button and act on it
1625             //Listen for the click on the down button and act on it
1626             Event.on(_b1, 'mousedown',function(ev) {
1627                 Event.stopEvent(ev);
1628             }, this, true);
1629             Event.on(_b2, 'mousedown', function(ev) {
1630                 Event.stopEvent(ev);
1631             }, this, true);
1632             Event.on(_b1, 'click', _intUp, this, true);
1633             Event.on(_b2, 'click', _intDown, this, true);
1634         },
1635         /**
1636         * @protected
1637         * @method _buttonClick
1638         * @description Click handler for all buttons in the toolbar.
1639         * @param {String} ev The event that was passed in.
1640         * @param {Object} info Object literal of information about the button that was clicked.
1641         */
1642         _buttonClick: function(ev, info) {
1643             var doEvent = true;
1644
1645             if (ev && ev.type == 'keypress') {
1646                 if (ev.keyCode == 9) {
1647                     doEvent = false;
1648                 } else if ((ev.keyCode === 13) || (ev.keyCode === 0) || (ev.keyCode === 32)) {
1649                 } else {
1650                     doEvent = false;
1651                 }
1652             }
1653
1654             if (doEvent) {
1655                 var fireNextEvent = true,
1656                     retValue = false;
1657
1658                 info.isSelected = this.isSelected(info.id);
1659
1660                 if (info.value) {
1661                     YAHOO.log('fireEvent::' + info.value + 'Click', 'info', 'Toolbar');
1662                     retValue = this.fireEvent(info.value + 'Click', { type: info.value + 'Click', target: this.get('element'), button: info });
1663                     if (retValue === false) {
1664                         fireNextEvent = false;
1665                     }
1666                 }
1667
1668                 if (info.menucmd && fireNextEvent) {
1669                     YAHOO.log('fireEvent::' + info.menucmd + 'Click', 'info', 'Toolbar');
1670                     retValue = this.fireEvent(info.menucmd + 'Click', { type: info.menucmd + 'Click', target: this.get('element'), button: info });
1671                     if (retValue === false) {
1672                         fireNextEvent = false;
1673                     }
1674                 }
1675                 if (fireNextEvent) {
1676                     YAHOO.log('fireEvent::buttonClick', 'info', 'Toolbar');
1677                     this.fireEvent('buttonClick', { type: 'buttonClick', target: this.get('element'), button: info });
1678                 }
1679
1680                 if (info.type == 'select') {
1681                     var button = this.getButtonById(info.id);
1682                     if (button.buttonType == 'rich') {
1683                         var txt = info.value;
1684                         for (var i = 0; i < info.menu.length; i++) {
1685                             if (info.menu[i].value == info.value) {
1686                                 txt = info.menu[i].text;
1687                                 break;
1688                             }
1689                         }
1690                         button.set('label', '<span class="yui-toolbar-' + info.menucmd + '-' + (info.value).replace(/ /g, '-').toLowerCase() + '">' + txt + '</span>');
1691                         var _items = button.getMenu().getItems();
1692                         for (var m = 0; m < _items.length; m++) {
1693                             if (_items[m].value.toLowerCase() == info.value.toLowerCase()) {
1694                                 _items[m].cfg.setProperty('checked', true);
1695                             } else {
1696                                 _items[m].cfg.setProperty('checked', false);
1697                             }
1698                         }
1699                     }
1700                 }
1701                 if (ev) {
1702                     Event.stopEvent(ev);
1703                 }
1704             }
1705         },
1706         /**
1707         * @private
1708         * @property _keyNav
1709         * @description Flag to determine if the arrow nav listeners have been attached
1710         * @type Boolean
1711         */
1712         _keyNav: null,
1713         /**
1714         * @private
1715         * @property _navCounter
1716         * @description Internal counter for walking the buttons in the toolbar with the arrow keys
1717         * @type Number
1718         */
1719         _navCounter: null,
1720         /**
1721         * @private
1722         * @method _navigateButtons
1723         * @description Handles the navigation/focus of toolbar buttons with the Arrow Keys
1724         * @param {Event} ev The Key Event
1725         */
1726         _navigateButtons: function(ev) {
1727             switch (ev.keyCode) {
1728                 case 37:
1729                 case 39:
1730                     if (ev.keyCode == 37) {
1731                         this._navCounter--;
1732                     } else {
1733                         this._navCounter++;
1734                     }
1735                     if (this._navCounter > (this._buttonList.length - 1)) {
1736                         this._navCounter = 0;
1737                     }
1738                     if (this._navCounter < 0) {
1739                         this._navCounter = (this._buttonList.length - 1);
1740                     }
1741                     if (this._buttonList[this._navCounter]) {
1742                         var el = this._buttonList[this._navCounter].get('element');
1743                         if (this.browser.ie) {
1744                             el = this._buttonList[this._navCounter].get('element').getElementsByTagName('a')[0];
1745                         }
1746                         if (this._buttonList[this._navCounter].get('disabled')) {
1747                             this._navigateButtons(ev);
1748                         } else {
1749                             el.focus();
1750                         }
1751                     }
1752                     break;
1753             }
1754         },
1755         /**
1756         * @private
1757         * @method _handleFocus
1758         * @description Sets up the listeners for the arrow key navigation
1759         */
1760         _handleFocus: function() {
1761             if (!this._keyNav) {
1762                 var ev = 'keypress';
1763                 if (this.browser.ie) {
1764                     ev = 'keydown';
1765                 }
1766                 Event.on(this.get('element'), ev, this._navigateButtons, this, true);
1767                 this._keyNav = true;
1768                 this._navCounter = -1;
1769             }
1770         },
1771         /**
1772         * @method getButtonById
1773         * @description Gets a button instance from the toolbar by is Dom id.
1774         * @param {String} id The Dom id to query for.
1775         * @return {<a href="YAHOO.widget.ToolbarButton.html">YAHOO.widget.ToolbarButton</a>}
1776         */
1777         getButtonById: function(id) {
1778             var len = this._buttonList.length;
1779             for (var i = 0; i < len; i++) {
1780                 if (this._buttonList[i] && this._buttonList[i].get('id') == id) {
1781                     return this._buttonList[i];
1782                 }
1783             }
1784             return false;
1785         },
1786         /**
1787         * @method getButtonByValue
1788         * @description Gets a button instance or a menuitem instance from the toolbar by it's value.
1789         * @param {String} value The button value to query for.
1790         * @return {<a href="YAHOO.widget.ToolbarButton.html">YAHOO.widget.ToolbarButton</a> or <a href="YAHOO.widget.MenuItem.html">YAHOO.widget.MenuItem</a>}
1791         */
1792         getButtonByValue: function(value) {
1793             var _buttons = this.get('buttons');
1794             var len = _buttons.length;
1795             for (var i = 0; i < len; i++) {
1796                 if (_buttons[i].group !== undefined) {
1797                     for (var m = 0; m < _buttons[i].buttons.length; m++) {
1798                         if ((_buttons[i].buttons[m].value == value) || (_buttons[i].buttons[m].menucmd == value)) {
1799                             return this.getButtonById(_buttons[i].buttons[m].id);
1800                         }
1801                         if (_buttons[i].buttons[m].menu) { //Menu Button, loop through the values
1802                             for (var s = 0; s < _buttons[i].buttons[m].menu.length; s++) {
1803                                 if (_buttons[i].buttons[m].menu[s].value == value) {
1804                                     return this.getButtonById(_buttons[i].buttons[m].id);
1805                                 }
1806                             }
1807                         }
1808                     }
1809                 } else {
1810                     if ((_buttons[i].value == value) || (_buttons[i].menucmd == value)) {
1811                         return this.getButtonById(_buttons[i].id);
1812                     }
1813                     if (_buttons[i].menu) { //Menu Button, loop through the values
1814                         for (var j = 0; j < _buttons[i].menu.length; j++) {
1815                             if (_buttons[i].menu[j].value == value) {
1816                                 return this.getButtonById(_buttons[i].id);
1817                             }
1818                         }
1819                     }
1820                 }
1821             }
1822             return false;
1823         },
1824         /**
1825         * @method getButtonByIndex
1826         * @description Gets a button instance from the toolbar by is index in _buttonList.
1827         * @param {Number} index The index of the button in _buttonList.
1828         * @return {<a href="YAHOO.widget.ToolbarButton.html">YAHOO.widget.ToolbarButton</a>}
1829         */
1830         getButtonByIndex: function(index) {
1831             if (this._buttonList[index]) {
1832                 return this._buttonList[index];
1833             } else {
1834                 return false;
1835             }
1836         },
1837         /**
1838         * @method getButtons
1839         * @description Returns an array of buttons in the current toolbar
1840         * @return {Array}
1841         */
1842         getButtons: function() {
1843             return this._buttonList;
1844         },
1845         /**
1846         * @method disableButton
1847         * @description Disables a button in the toolbar.
1848         * @param {String/Number} id Disable a button by it's id, index or value.
1849         * @return {Boolean}
1850         */
1851         disableButton: function(id) {
1852             var button = getButton.call(this, id);
1853             if (button) {
1854                 button.set('disabled', true);
1855             } else {
1856                 return false;
1857             }
1858         },
1859         /**
1860         * @method enableButton
1861         * @description Enables a button in the toolbar.
1862         * @param {String/Number} id Enable a button by it's id, index or value.
1863         * @return {Boolean}
1864         */
1865         enableButton: function(id) {
1866             if (this.get('disabled')) {
1867                 return false;
1868             }
1869             var button = getButton.call(this, id);
1870             if (button) {
1871                 if (button.get('disabled')) {
1872                     button.set('disabled', false);
1873                 }
1874             } else {
1875                 return false;
1876             }
1877         },
1878         /**
1879         * @method isSelected
1880         * @description Tells if a button is selected or not.
1881         * @param {String/Number} id A button by it's id, index or value.
1882         * @return {Boolean}
1883         */
1884         isSelected: function(id) {
1885             var button = getButton.call(this, id);
1886             if (button) {
1887                 return button._selected;
1888             }
1889             return false;
1890         },
1891         /**
1892         * @method selectButton
1893         * @description Selects a button in the toolbar.
1894         * @param {String/Number} id Select a button by it's id, index or value.
1895         * @param {String} value If this is a Menu Button, check this item in the menu
1896         * @return {Boolean}
1897         */
1898         selectButton: function(id, value) {
1899             var button = getButton.call(this, id);
1900             if (button) {
1901                 button.addClass('yui-button-selected');
1902                 button.addClass('yui-button-' + button.get('value') + '-selected');
1903                 button._selected = true;
1904                 if (value) {
1905                     if (button.buttonType == 'rich') {
1906                         var _items = button.getMenu().getItems();
1907                         for (var m = 0; m < _items.length; m++) {
1908                             if (_items[m].value == value) {
1909                                 _items[m].cfg.setProperty('checked', true);
1910                                 button.set('label', '<span class="yui-toolbar-' + button.get('value') + '-' + (value).replace(/ /g, '-').toLowerCase() + '">' + _items[m]._oText.nodeValue + '</span>');
1911                             } else {
1912                                 _items[m].cfg.setProperty('checked', false);
1913                             }
1914                         }
1915                     }
1916                 }
1917             } else {
1918                 return false;
1919             }
1920         },
1921         /**
1922         * @method deselectButton
1923         * @description Deselects a button in the toolbar.
1924         * @param {String/Number} id Deselect a button by it's id, index or value.
1925         * @return {Boolean}
1926         */
1927         deselectButton: function(id) {
1928             var button = getButton.call(this, id);
1929             if (button) {
1930                 button.removeClass('yui-button-selected');
1931                 button.removeClass('yui-button-' + button.get('value') + '-selected');
1932                 button.removeClass('yui-button-hover');
1933                 button._selected = false;
1934             } else {
1935                 return false;
1936             }
1937         },
1938         /**
1939         * @method deselectAllButtons
1940         * @description Deselects all buttons in the toolbar.
1941         * @return {Boolean}
1942         */
1943         deselectAllButtons: function() {
1944             var len = this._buttonList.length;
1945             for (var i = 0; i < len; i++) {
1946                 this.deselectButton(this._buttonList[i]);
1947             }
1948         },
1949         /**
1950         * @method disableAllButtons
1951         * @description Disables all buttons in the toolbar.
1952         * @return {Boolean}
1953         */
1954         disableAllButtons: function() {
1955             if (this.get('disabled')) {
1956                 return false;
1957             }
1958             var len = this._buttonList.length;
1959             for (var i = 0; i < len; i++) {
1960                 this.disableButton(this._buttonList[i]);
1961             }
1962         },
1963         /**
1964         * @method enableAllButtons
1965         * @description Enables all buttons in the toolbar.
1966         * @return {Boolean}
1967         */
1968         enableAllButtons: function() {
1969             if (this.get('disabled')) {
1970                 return false;
1971             }
1972             var len = this._buttonList.length;
1973             for (var i = 0; i < len; i++) {
1974                 this.enableButton(this._buttonList[i]);
1975             }
1976         },
1977         /**
1978         * @method resetAllButtons
1979         * @description Resets all buttons to their initial state.
1980         * @param {Object} _ex Except these buttons
1981         * @return {Boolean}
1982         */
1983         resetAllButtons: function(_ex) {
1984             if (!Lang.isObject(_ex)) {
1985                 _ex = {};
1986             }
1987             if (this.get('disabled')) {
1988                 return false;
1989             }
1990             var len = this._buttonList.length;
1991             for (var i = 0; i < len; i++) {
1992                 var _button = this._buttonList[i];
1993                 if (_button) {
1994                     var disabled = _button._configs.disabled._initialConfig.value;
1995                     if (_ex[_button.get('id')]) {
1996                         this.enableButton(_button);
1997                         this.selectButton(_button);
1998                     } else {
1999                         if (disabled) {
2000                             this.disableButton(_button);
2001                         } else {
2002                             this.enableButton(_button);
2003                         }
2004                         this.deselectButton(_button);
2005                     }
2006                 }
2007             }
2008         },
2009         /**
2010         * @method destroyButton
2011         * @description Destroy a button in the toolbar.
2012         * @param {String/Number} id Destroy a button by it's id or index.
2013         * @return {Boolean}
2014         */
2015         destroyButton: function(id) {
2016             var button = getButton.call(this, id);
2017             if (button) {
2018                 var thisID = button.get('id');
2019                 button.destroy();
2020
2021                 var len = this._buttonList.length;
2022                 for (var i = 0; i < len; i++) {
2023                     if (this._buttonList[i] && this._buttonList[i].get('id') == thisID) {
2024                         this._buttonList[i] = null;
2025                     }
2026                 }
2027             } else {
2028                 return false;
2029             }
2030         },
2031         /**
2032         * @method destroy
2033         * @description Destroys the toolbar, all of it's elements and objects.
2034         * @return {Boolean}
2035         */
2036         destroy: function() {
2037             this.get('element').innerHTML = '';
2038             this.get('element').className = '';
2039             //Brutal Object Destroy
2040             for (var i in this) {
2041                 if (Lang.hasOwnProperty(this, i)) {
2042                     this[i] = null;
2043                 }
2044             }
2045             return true;
2046         },
2047         /**
2048         * @method collapse
2049         * @description Programatically collapse the toolbar.
2050         * @param {Boolean} collapse True to collapse, false to expand.
2051         */
2052         collapse: function(collapse) {
2053             var el = Dom.getElementsByClassName('collapse', 'span', this._titlebar);
2054             if (collapse === false) {
2055                 Dom.removeClass(this.get('cont').parentNode, 'yui-toolbar-container-collapsed');
2056                 if (el[0]) {
2057                     Dom.removeClass(el[0], 'collapsed');
2058                 }
2059                 this.fireEvent('toolbarExpanded', { type: 'toolbarExpanded', target: this });
2060             } else {
2061                 if (el[0]) {
2062                     Dom.addClass(el[0], 'collapsed');
2063                 }
2064                 Dom.addClass(this.get('cont').parentNode, 'yui-toolbar-container-collapsed');
2065                 this.fireEvent('toolbarCollapsed', { type: 'toolbarCollapsed', target: this });
2066             }
2067         },
2068         /**
2069         * @method toString
2070         * @description Returns a string representing the toolbar.
2071         * @return {String}
2072         */
2073         toString: function() {
2074             return 'Toolbar (#' + this.get('element').id + ') with ' + this._buttonList.length + ' buttons.';
2075         }
2076     });
2077 /**
2078 * @event buttonClick
2079 * @param {Object} o The object passed to this handler is the button config used to create the button.
2080 * @description Fires when any botton receives a click event. Passes back a single object representing the buttons config object. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
2081 * @type YAHOO.util.CustomEvent
2082 */
2083 /**
2084 * @event valueClick
2085 * @param {Object} o The object passed to this handler is the button config used to create the button.
2086 * @description This is a special dynamic event that is created and dispatched based on the value property
2087 * of the button config. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
2088 * Example:
2089 * <code><pre>
2090 * buttons : [
2091 *   { type: 'button', value: 'test', value: 'testButton' }
2092 * ]</pre>
2093 * </code>
2094 * With the valueClick event you could subscribe to this buttons click event with this:
2095 * tbar.in('testButtonClick', function() { alert('test button clicked'); })
2096 * @type YAHOO.util.CustomEvent
2097 */
2098 /**
2099 * @event toolbarExpanded
2100 * @description Fires when the toolbar is expanded via the collapse button. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
2101 * @type YAHOO.util.CustomEvent
2102 */
2103 /**
2104 * @event toolbarCollapsed
2105 * @description Fires when the toolbar is collapsed via the collapse button. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
2106 * @type YAHOO.util.CustomEvent
2107 */
2108 })();
2109 /**
2110  * @module editor
2111  * @description <p>The Rich Text Editor is a UI control that replaces a standard HTML textarea; it allows for the rich formatting of text content, including common structural treatments like lists, formatting treatments like bold and italic text, and drag-and-drop inclusion and sizing of images. The Rich Text Editor's toolbar is extensible via a plugin architecture so that advanced implementations can achieve a high degree of customization.</p>
2112  * @namespace YAHOO.widget
2113  * @requires yahoo, dom, element, event, toolbar
2114  * @optional animation, container_core, resize, dragdrop
2115  */
2116
2117 (function() {
2118 var Dom = YAHOO.util.Dom,
2119     Event = YAHOO.util.Event,
2120     Lang = YAHOO.lang,
2121     Toolbar = YAHOO.widget.Toolbar;
2122
2123     /**
2124      * The Rich Text Editor is a UI control that replaces a standard HTML textarea; it allows for the rich formatting of text content, including common structural treatments like lists, formatting treatments like bold and italic text, and drag-and-drop inclusion and sizing of images. The Rich Text Editor's toolbar is extensible via a plugin architecture so that advanced implementations can achieve a high degree of customization.
2125      * @constructor
2126      * @class SimpleEditor
2127      * @extends YAHOO.util.Element
2128      * @param {String/HTMLElement} el The textarea element to turn into an editor.
2129      * @param {Object} attrs Object liternal containing configuration parameters.
2130     */
2131
2132     YAHOO.widget.SimpleEditor = function(el, attrs) {
2133         YAHOO.log('SimpleEditor Initalizing', 'info', 'SimpleEditor');
2134
2135         var o = {};
2136         if (Lang.isObject(el) && (!el.tagName) && !attrs) {
2137             Lang.augmentObject(o, el); //Break the config reference
2138             el = document.createElement('textarea');
2139             this.DOMReady = true;
2140             if (o.container) {
2141                 var c = Dom.get(o.container);
2142                 c.appendChild(el);
2143             } else {
2144                 document.body.appendChild(el);
2145             }
2146         } else {
2147             if (attrs) {
2148                 Lang.augmentObject(o, attrs); //Break the config reference
2149             }
2150         }
2151
2152         var oConfig = {
2153             element: null,
2154             attributes: o
2155         }, id = null;
2156
2157         if (Lang.isString(el)) {
2158             id = el;
2159         } else {
2160             if (oConfig.attributes.id) {
2161                 id = oConfig.attributes.id;
2162             } else {
2163                 this.DOMReady = true;
2164                 id = Dom.generateId(el);
2165             }
2166         }
2167         oConfig.element = el;
2168
2169         var element_cont = document.createElement('DIV');
2170         oConfig.attributes.element_cont = new YAHOO.util.Element(element_cont, {
2171             id: id + '_container'
2172         });
2173         var div = document.createElement('div');
2174         Dom.addClass(div, 'first-child');
2175         oConfig.attributes.element_cont.appendChild(div);
2176
2177         if (!oConfig.attributes.toolbar_cont) {
2178             oConfig.attributes.toolbar_cont = document.createElement('DIV');
2179             oConfig.attributes.toolbar_cont.id = id + '_toolbar';
2180             div.appendChild(oConfig.attributes.toolbar_cont);
2181         }
2182         var editorWrapper = document.createElement('DIV');
2183         div.appendChild(editorWrapper);
2184         oConfig.attributes.editor_wrapper = editorWrapper;
2185
2186         YAHOO.widget.SimpleEditor.superclass.constructor.call(this, oConfig.element, oConfig.attributes);
2187     };
2188
2189
2190     YAHOO.extend(YAHOO.widget.SimpleEditor, YAHOO.util.Element, {
2191         /**
2192         * @private
2193         * @property _resizeConfig
2194         * @description The default config for the Resize Utility
2195         */
2196         _resizeConfig: {
2197             handles: ['br'],
2198             autoRatio: true,
2199             status: true,
2200             proxy: true,
2201             useShim: true,
2202             setSize: false
2203         },
2204         /**
2205         * @private
2206         * @method _setupResize
2207         * @description Creates the Resize instance and binds its events.
2208         */
2209         _setupResize: function() {
2210             if (!YAHOO.util.DD || !YAHOO.util.Resize) { return false; }
2211             if (this.get('resize')) {
2212                 var config = {};
2213                 Lang.augmentObject(config, this._resizeConfig); //Break the config reference
2214                 this.resize = new YAHOO.util.Resize(this.get('element_cont').get('element'), config);
2215                 this.resize.on('resize', function(args) {
2216                     var anim = this.get('animate');
2217                     this.set('animate', false);
2218                     this.set('width', args.width + 'px');
2219                     var h = args.height,
2220                         th = (this.toolbar.get('element').clientHeight + 2),
2221                         dh = 0;
2222                     if (this.dompath) {
2223                         dh = (this.dompath.clientHeight + 1); //It has a 1px top border..
2224                     }
2225                     var newH = (h - th - dh);
2226                     this.set('height', newH + 'px');
2227                     this.get('element_cont').setStyle('height', '');
2228                     this.set('animate', anim);
2229                 }, this, true);
2230             }
2231         },
2232         /**
2233         * @property resize
2234         * @description A reference to the Resize object
2235         * @type YAHOO.util.Resize
2236         */
2237         resize: null,
2238         /**
2239         * @private
2240         * @method _setupDD
2241         * @description Sets up the DD instance used from the 'drag' config option.
2242         */
2243         _setupDD: function() {
2244             if (!YAHOO.util.DD) { return false; }
2245             if (this.get('drag')) {
2246                 YAHOO.log('Attaching DD instance to Editor', 'info', 'SimpleEditor');
2247                 var d = this.get('drag'),
2248                     dd = YAHOO.util.DD;
2249                 if (d === 'proxy') {
2250                     dd = YAHOO.util.DDProxy;
2251                 }
2252
2253                 this.dd = new dd(this.get('element_cont').get('element'));
2254                 this.toolbar.addClass('draggable');
2255                 this.dd.setHandleElId(this.toolbar._titlebar);
2256             }
2257         },
2258         /**
2259         * @property dd
2260         * @description A reference to the DragDrop object.
2261         * @type YAHOO.util.DD/YAHOO.util.DDProxy
2262         */
2263         dd: null,
2264         /**
2265         * @private
2266         * @property _lastCommand
2267         * @description A cache of the last execCommand (used for Undo/Redo so they don't mark an undo level)
2268         * @type String
2269         */
2270         _lastCommand: null,
2271         _undoNodeChange: function() {},
2272         _storeUndo: function() {},
2273         /**
2274         * @private
2275         * @method _checkKey
2276         * @description Checks a keyMap entry against a key event
2277         * @param {Object} k The _keyMap object
2278         * @param {Event} e The Mouse Event
2279         * @return {Boolean}
2280         */
2281         _checkKey: function(k, e) {
2282             var ret = false;
2283             if ((e.keyCode === k.key)) {
2284                 if (k.mods && (k.mods.length > 0)) {
2285                     var val = 0;
2286                     for (var i = 0; i < k.mods.length; i++) {
2287                         if (this.browser.mac) {
2288                             if (k.mods[i] == 'ctrl') {
2289                                 k.mods[i] = 'meta';
2290                             }
2291                         }
2292                         if (e[k.mods[i] + 'Key'] === true) {
2293                             val++;
2294                         }
2295                     }
2296                     if (val === k.mods.length) {
2297                         ret = true;
2298                     }
2299                 } else {
2300                     ret = true;
2301                 }
2302             }
2303             //YAHOO.log('Shortcut Key Check: (' + k.key + ') return: ' + ret, 'info', 'SimpleEditor');
2304             return ret;
2305         },
2306         /**
2307         * @private
2308         * @property _keyMap
2309         * @description Named key maps for various actions in the Editor. Example: <code>CLOSE_WINDOW: { key: 87, mods: ['shift', 'ctrl'] }</code>.
2310         * This entry shows that when key 87 (W) is found with the modifiers of shift and control, the window will close. You can customize this object to tweak keyboard shortcuts.
2311         * @type {Object/Mixed}
2312         */
2313         _keyMap: {
2314             SELECT_ALL: {
2315                 key: 65, //A key
2316                 mods: ['ctrl']
2317             },
2318             CLOSE_WINDOW: {
2319                 key: 87, //W key
2320                 mods: ['shift', 'ctrl']
2321             },
2322             FOCUS_TOOLBAR: {
2323                 key: 27,
2324                 mods: ['shift']
2325             },
2326             FOCUS_AFTER: {
2327                 key: 27
2328             },
2329             FONT_SIZE_UP: {
2330                 key: 38,
2331                 mods: ['shift', 'ctrl']
2332             },
2333             FONT_SIZE_DOWN: {
2334                 key: 40,
2335                 mods: ['shift', 'ctrl']
2336             },
2337             CREATE_LINK: {
2338                 key: 76,
2339                 mods: ['shift', 'ctrl']
2340             },
2341             BOLD: {
2342                 key: 66,
2343                 mods: ['shift', 'ctrl']
2344             },
2345             ITALIC: {
2346                 key: 73,
2347                 mods: ['shift', 'ctrl']
2348             },
2349             UNDERLINE: {
2350                 key: 85,
2351                 mods: ['shift', 'ctrl']
2352             },
2353             UNDO: {
2354                 key: 90,
2355                 mods: ['ctrl']
2356             },
2357             REDO: {
2358                 key: 90,
2359                 mods: ['shift', 'ctrl']
2360             },
2361             JUSTIFY_LEFT: {
2362                 key: 219,
2363                 mods: ['shift', 'ctrl']
2364             },
2365             JUSTIFY_CENTER: {
2366                 key: 220,
2367                 mods: ['shift', 'ctrl']
2368             },
2369             JUSTIFY_RIGHT: {
2370                 key: 221,
2371                 mods: ['shift', 'ctrl']
2372             }
2373         },
2374         /**
2375         * @private
2376         * @method _cleanClassName
2377         * @description Makes a useable classname from dynamic data, by dropping it to lowercase and replacing spaces with -'s.
2378         * @param {String} str The classname to clean up
2379         * @return {String}
2380         */
2381         _cleanClassName: function(str) {
2382             return str.replace(/ /g, '-').toLowerCase();
2383         },
2384         /**
2385         * @property _textarea
2386         * @description Flag to determine if we are using a textarea or an HTML Node.
2387         * @type Boolean
2388         */
2389         _textarea: null,
2390         /**
2391         * @property _docType
2392         * @description The DOCTYPE to use in the editable container.
2393         * @type String
2394         */
2395         _docType: '<!DOCTYPE HTML PUBLIC "-/'+'/W3C/'+'/DTD HTML 4.01/'+'/EN" "http:/'+'/www.w3.org/TR/html4/strict.dtd">',
2396         /**
2397         * @property editorDirty
2398         * @description This flag will be set when certain things in the Editor happen. It is to be used by the developer to check to see if content has changed.
2399         * @type Boolean
2400         */
2401         editorDirty: null,
2402         /**
2403         * @property _defaultCSS
2404         * @description The default CSS used in the config for 'css'. This way you can add to the config like this: { css: YAHOO.widget.SimpleEditor.prototype._defaultCSS + 'ADD MYY CSS HERE' }
2405         * @type String
2406         */
2407         _defaultCSS: 'html { height: 95%; } body { padding: 7px; background-color: #fff; font: 13px/1.22 arial,helvetica,clean,sans-serif;*font-size:small;*font:x-small; } a, a:visited, a:hover { color: blue !important; text-decoration: underline !important; cursor: text !important; } .warning-localfile { border-bottom: 1px dashed red !important; } .yui-busy { cursor: wait !important; } img.selected { border: 2px dotted #808080; } img { cursor: pointer !important; border: none; } body.ptags.webkit div.yui-wk-p { margin: 11px 0; } body.ptags.webkit div.yui-wk-div { margin: 0; }',
2408         /**
2409         * @property _defaultToolbar
2410         * @private
2411         * @description Default toolbar config.
2412         * @type Object
2413         */
2414         _defaultToolbar: null,
2415         /**
2416         * @property _lastButton
2417         * @private
2418         * @description The last button pressed, so we don't disable it.
2419         * @type Object
2420         */
2421         _lastButton: null,
2422         /**
2423         * @property _baseHREF
2424         * @private
2425         * @description The base location of the editable page (this page) so that relative paths for image work.
2426         * @type String
2427         */
2428         _baseHREF: function() {
2429             var href = document.location.href;
2430             if (href.indexOf('?') !== -1) { //Remove the query string
2431                 href = href.substring(0, href.indexOf('?'));
2432             }
2433             href = href.substring(0, href.lastIndexOf('/')) + '/';
2434             return href;
2435         }(),
2436         /**
2437         * @property _lastImage
2438         * @private
2439         * @description Safari reference for the last image selected (for styling as selected).
2440         * @type HTMLElement
2441         */
2442         _lastImage: null,
2443         /**
2444         * @property _blankImageLoaded
2445         * @private
2446         * @description Don't load the blank image more than once..
2447         * @type Boolean
2448         */
2449         _blankImageLoaded: null,
2450         /**
2451         * @property _fixNodesTimer
2452         * @private
2453         * @description Holder for the fixNodes timer
2454         * @type Date
2455         */
2456         _fixNodesTimer: null,
2457         /**
2458         * @property _nodeChangeTimer
2459         * @private
2460         * @description Holds a reference to the nodeChange setTimeout call
2461         * @type Number
2462         */
2463         _nodeChangeTimer: null,
2464         /**
2465         * @property _lastNodeChangeEvent
2466         * @private
2467         * @description Flag to determine the last event that fired a node change
2468         * @type Event
2469         */
2470         _lastNodeChangeEvent: null,
2471         /**
2472         * @property _lastNodeChange
2473         * @private
2474         * @description Flag to determine when the last node change was fired
2475         * @type Date
2476         */
2477         _lastNodeChange: 0,
2478         /**
2479         * @property _rendered
2480         * @private
2481         * @description Flag to determine if editor has been rendered or not
2482         * @type Boolean
2483         */
2484         _rendered: null,
2485         /**
2486         * @property DOMReady
2487         * @private
2488         * @description Flag to determine if DOM is ready or not
2489         * @type Boolean
2490         */
2491         DOMReady: null,
2492         /**
2493         * @property _selection
2494         * @private
2495         * @description Holder for caching iframe selections
2496         * @type Object
2497         */
2498         _selection: null,
2499         /**
2500         * @property _mask
2501         * @private
2502         * @description DOM Element holder for the editor Mask when disabled
2503         * @type Object
2504         */
2505         _mask: null,
2506         /**
2507         * @property _showingHiddenElements
2508         * @private
2509         * @description Status of the hidden elements button
2510         * @type Boolean
2511         */
2512         _showingHiddenElements: null,
2513         /**
2514         * @property currentWindow
2515         * @description A reference to the currently open EditorWindow
2516         * @type Object
2517         */
2518         currentWindow: null,
2519         /**
2520         * @property currentEvent
2521         * @description A reference to the current editor event
2522         * @type Event
2523         */
2524         currentEvent: null,
2525         /**
2526         * @property operaEvent
2527         * @private
2528         * @description setTimeout holder for Opera and Image DoubleClick event..
2529         * @type Object
2530         */
2531         operaEvent: null,
2532         /**
2533         * @property currentFont
2534         * @description A reference to the last font selected from the Toolbar
2535         * @type HTMLElement
2536         */
2537         currentFont: null,
2538         /**
2539         * @property currentElement
2540         * @description A reference to the current working element in the editor
2541         * @type Array
2542         */
2543         currentElement: null,
2544         /**
2545         * @property dompath
2546         * @description A reference to the dompath container for writing the current working dom path to.
2547         * @type HTMLElement
2548         */
2549         dompath: null,
2550         /**
2551         * @property beforeElement
2552         * @description A reference to the H2 placed before the editor for Accessibilty.
2553         * @type HTMLElement
2554         */
2555         beforeElement: null,
2556         /**
2557         * @property afterElement
2558         * @description A reference to the H2 placed after the editor for Accessibilty.
2559         * @type HTMLElement
2560         */
2561         afterElement: null,
2562         /**
2563         * @property invalidHTML
2564         * @description Contains a list of HTML elements that are invalid inside the editor. They will be removed when they are found. If you set the value of a key to "{ keepContents: true }", then the element will be replaced with a yui-non span to be filtered out when cleanHTML is called. The only tag that is ignored here is the span tag as it will force the Editor into a loop and freeze the browser. However.. all of these tags will be removed in the cleanHTML routine.
2565         * @type Object
2566         */
2567         invalidHTML: {
2568             form: true,
2569             input: true,
2570             button: true,
2571             select: true,
2572             link: true,
2573             html: true,
2574             body: true,
2575             iframe: true,
2576             script: true,
2577             style: true,
2578             textarea: true
2579         },
2580         /**
2581         * @property toolbar
2582         * @description Local property containing the <a href="YAHOO.widget.Toolbar.html">YAHOO.widget.Toolbar</a> instance
2583         * @type <a href="YAHOO.widget.Toolbar.html">YAHOO.widget.Toolbar</a>
2584         */
2585         toolbar: null,
2586         /**
2587         * @private
2588         * @property _contentTimer
2589         * @description setTimeout holder for documentReady check
2590         */
2591         _contentTimer: null,
2592         /**
2593         * @private
2594         * @property _contentTimerCounter
2595         * @description Counter to check the number of times the body is polled for before giving up
2596         * @type Number
2597         */
2598         _contentTimerCounter: 0,
2599         /**
2600         * @private
2601         * @property _disabled
2602         * @description The Toolbar items that should be disabled if there is no selection present in the editor.
2603         * @type Array
2604         */
2605         _disabled: [ 'createlink', 'fontname', 'fontsize', 'forecolor', 'backcolor' ],
2606         /**
2607         * @private
2608         * @property _alwaysDisabled
2609         * @description The Toolbar items that should ALWAYS be disabled event if there is a selection present in the editor.
2610         * @type Object
2611         */
2612         _alwaysDisabled: { undo: true, redo: true },
2613         /**
2614         * @private
2615         * @property _alwaysEnabled
2616         * @description The Toolbar items that should ALWAYS be enabled event if there isn't a selection present in the editor.
2617         * @type Object
2618         */
2619         _alwaysEnabled: { },
2620         /**
2621         * @private
2622         * @property _semantic
2623         * @description The Toolbar commands that we should attempt to make tags out of instead of using styles.
2624         * @type Object
2625         */
2626         _semantic: { 'bold': true, 'italic' : true, 'underline' : true },
2627         /**
2628         * @private
2629         * @property _tag2cmd
2630         * @description A tag map of HTML tags to convert to the different types of commands so we can select the proper toolbar button.
2631         * @type Object
2632         */
2633         _tag2cmd: {
2634             'b': 'bold',
2635             'strong': 'bold',
2636             'i': 'italic',
2637             'em': 'italic',
2638             'u': 'underline',
2639             'sup': 'superscript',
2640             'sub': 'subscript',
2641             'img': 'insertimage',
2642             'a' : 'createlink',
2643             'ul' : 'insertunorderedlist',
2644             'ol' : 'insertorderedlist'
2645         },
2646
2647         /**
2648         * @private _createIframe
2649         * @description Creates the DOM and YUI Element for the iFrame editor area.
2650         * @param {String} id The string ID to prefix the iframe with
2651         * @return {Object} iFrame object
2652         */
2653         _createIframe: function() {
2654             var ifrmDom = document.createElement('iframe');
2655             ifrmDom.id = this.get('id') + '_editor';
2656             var config = {
2657                 border: '0',
2658                 frameBorder: '0',
2659                 marginWidth: '0',
2660                 marginHeight: '0',
2661                 leftMargin: '0',
2662                 topMargin: '0',
2663                 allowTransparency: 'true',
2664                 width: '100%'
2665             };
2666             if (this.get('autoHeight')) {
2667                 config.scrolling = 'no';
2668             }
2669             for (var i in config) {
2670                 if (Lang.hasOwnProperty(config, i)) {
2671                     ifrmDom.setAttribute(i, config[i]);
2672                 }
2673             }
2674             var isrc = 'javascript:;';
2675             if (this.browser.ie) {
2676                 //isrc = 'about:blank';
2677                 //TODO - Check this, I have changed it before..
2678                 isrc = 'javascript:false;';
2679             }
2680             ifrmDom.setAttribute('src', isrc);
2681             var ifrm = new YAHOO.util.Element(ifrmDom);
2682             ifrm.setStyle('visibility', 'hidden');
2683             return ifrm;
2684         },
2685         /**
2686         * @private _isElement
2687         * @description Checks to see if an Element reference is a valid one and has a certain tag type
2688         * @param {HTMLElement} el The element to check
2689         * @param {String} tag The tag that the element needs to be
2690         * @return {Boolean}
2691         */
2692         _isElement: function(el, tag) {
2693             if (el && el.tagName && (el.tagName.toLowerCase() == tag)) {
2694                 return true;
2695             }
2696             if (el && el.getAttribute && (el.getAttribute('tag') == tag)) {
2697                 return true;
2698             }
2699             return false;
2700         },
2701         /**
2702         * @private _hasParent
2703         * @description Checks to see if an Element reference or one of it's parents is a valid one and has a certain tag type
2704         * @param {HTMLElement} el The element to check
2705         * @param {String} tag The tag that the element needs to be
2706         * @return HTMLElement
2707         */
2708         _hasParent: function(el, tag) {
2709             if (!el || !el.parentNode) {
2710                 return false;
2711             }
2712
2713             while (el.parentNode) {
2714                 if (this._isElement(el, tag)) {
2715                     return el;
2716                 }
2717                 if (el.parentNode) {
2718                     el = el.parentNode;
2719                 } else {
2720                     return false;
2721                 }
2722             }
2723             return false;
2724         },
2725         /**
2726         * @private
2727         * @method _getDoc
2728         * @description Get the Document of the IFRAME
2729         * @return {Object}
2730         */
2731         _getDoc: function() {
2732             var value = false;
2733             if (this.get) {
2734                 if (this.get('iframe')) {
2735                     if (this.get('iframe').get) {
2736                         if (this.get('iframe').get('element')) {
2737                             try {
2738                                 if (this.get('iframe').get('element').contentWindow) {
2739                                     if (this.get('iframe').get('element').contentWindow.document) {
2740                                         value = this.get('iframe').get('element').contentWindow.document;
2741                                         return value;
2742                                     }
2743                                 }
2744                             } catch (e) {}
2745                         }
2746                     }
2747                 }
2748             }
2749             return false;
2750         },
2751         /**
2752         * @private
2753         * @method _getWindow
2754         * @description Get the Window of the IFRAME
2755         * @return {Object}
2756         */
2757         _getWindow: function() {
2758             return this.get('iframe').get('element').contentWindow;
2759         },
2760         /**
2761         * @method focus
2762         * @description Attempt to set the focus of the iframes window.
2763         */
2764         focus: function() {
2765             this._getWindow().focus();
2766         },
2767         /**
2768         * @private
2769         * @depreciated - This should not be used, moved to this.focus();
2770         * @method _focusWindow
2771         * @description Attempt to set the focus of the iframes window.
2772         */
2773         _focusWindow: function() {
2774             YAHOO.log('_focusWindow: depreciated in favor of this.focus()', 'warn', 'Editor');
2775             this.focus();
2776         },
2777         /**
2778         * @private
2779         * @method _hasSelection
2780         * @description Determines if there is a selection in the editor document.
2781         * @return {Boolean}
2782         */
2783         _hasSelection: function() {
2784             var sel = this._getSelection();
2785             var range = this._getRange();
2786             var hasSel = false;
2787
2788             if (!sel || !range) {
2789                 return hasSel;
2790             }
2791
2792             //Internet Explorer
2793             if (this.browser.ie || this.browser.opera) {
2794                 if (range.text) {
2795                     hasSel = true;
2796                 }
2797                 if (range.html) {
2798                     hasSel = true;
2799                 }
2800             } else {
2801                 if (this.browser.webkit) {
2802                     if (sel+'' !== '') {
2803                         hasSel = true;
2804                     }
2805                 } else {
2806                     if (sel && (sel.toString() !== '') && (sel !== undefined)) {
2807                         hasSel = true;
2808                     }
2809                 }
2810             }
2811             return hasSel;
2812         },
2813         /**
2814         * @private
2815         * @method _getSelection
2816         * @description Handles the different selection objects across the A-Grade list.
2817         * @return {Object} Selection Object
2818         */
2819         _getSelection: function() {
2820             var _sel = null;
2821             if (this._getDoc() && this._getWindow()) {
2822                 if (this._getDoc().selection) {
2823                     _sel = this._getDoc().selection;
2824                 } else {
2825                     _sel = this._getWindow().getSelection();
2826                 }
2827                 //Handle Safari's lack of Selection Object
2828                 if (this.browser.webkit) {
2829                     if (_sel.baseNode) {
2830                             this._selection = {};
2831                             this._selection.baseNode = _sel.baseNode;
2832                             this._selection.baseOffset = _sel.baseOffset;
2833                             this._selection.extentNode = _sel.extentNode;
2834                             this._selection.extentOffset = _sel.extentOffset;
2835                     } else if (this._selection !== null) {
2836                         _sel = this._getWindow().getSelection();
2837                         _sel.setBaseAndExtent(
2838                             this._selection.baseNode,
2839                             this._selection.baseOffset,
2840                             this._selection.extentNode,
2841                             this._selection.extentOffset);
2842                         this._selection = null;
2843                     }
2844                 }
2845             }
2846             return _sel;
2847         },
2848         /**
2849         * @private
2850         * @method _selectNode
2851         * @description Places the highlight around a given node
2852         * @param {HTMLElement} node The node to select
2853         */
2854         _selectNode: function(node, collapse) {
2855             if (!node) {
2856                 return false;
2857             }
2858             var sel = this._getSelection(),
2859                 range = null;
2860
2861             if (this.browser.ie) {
2862                 try { //IE freaks out here sometimes..
2863                     range = this._getDoc().body.createTextRange();
2864                     range.moveToElementText(node);
2865                     range.select();
2866                 } catch (e) {
2867                     YAHOO.log('IE failed to select element: ' + node.tagName, 'warn', 'SimpleEditor');
2868                 }
2869             } else if (this.browser.webkit) {
2870                 if (collapse) {
2871                                     sel.setBaseAndExtent(node, 1, node, node.innerText.length);
2872                 } else {
2873                                     sel.setBaseAndExtent(node, 0, node, node.innerText.length);
2874                 }
2875             } else if (this.browser.opera) {
2876                 sel = this._getWindow().getSelection();
2877                 range = this._getDoc().createRange();
2878                 range.selectNode(node);
2879                 sel.removeAllRanges();
2880                 sel.addRange(range);
2881             } else {
2882                 range = this._getDoc().createRange();
2883                 range.selectNodeContents(node);
2884                 sel.removeAllRanges();
2885                 sel.addRange(range);
2886             }
2887             //TODO - Check Performance
2888             this.nodeChange();
2889         },
2890         /**
2891         * @private
2892         * @method _getRange
2893         * @description Handles the different range objects across the A-Grade list.
2894         * @return {Object} Range Object
2895         */
2896         _getRange: function() {
2897             var sel = this._getSelection();
2898
2899             if (sel === null) {
2900                 return null;
2901             }
2902
2903             if (this.browser.webkit && !sel.getRangeAt) {
2904                 var _range = this._getDoc().createRange();
2905                 try {
2906                     _range.setStart(sel.anchorNode, sel.anchorOffset);
2907                     _range.setEnd(sel.focusNode, sel.focusOffset);
2908                 } catch (e) {
2909                     _range = this._getWindow().getSelection()+'';
2910                 }
2911                 return _range;
2912             }
2913
2914             if (this.browser.ie || this.browser.opera) {
2915                 try {
2916                     return sel.createRange();
2917                 } catch (e2) {
2918                     return null;
2919                 }
2920             }
2921
2922             if (sel.rangeCount > 0) {
2923                 return sel.getRangeAt(0);
2924             }
2925             return null;
2926         },
2927         /**
2928         * @private
2929         * @method _setDesignMode
2930         * @description Sets the designMode of the iFrame document.
2931         * @param {String} state This should be either on or off
2932         */
2933         _setDesignMode: function(state) {
2934             try {
2935                 var set = true;
2936                 //SourceForge Bug #1807057
2937                 if (this.browser.ie && (state.toLowerCase() == 'off')) {
2938                     set = false;
2939                 }
2940                 if (set) {
2941                     this._getDoc().designMode = state;
2942                 }
2943             } catch(e) { }
2944         },
2945         /**
2946         * @private
2947         * @method _toggleDesignMode
2948         * @description Toggles the designMode of the iFrame document on and off.
2949         * @return {String} The state that it was set to.
2950         */
2951         _toggleDesignMode: function() {
2952             var _dMode = this._getDoc().designMode.toLowerCase(),
2953                 _state = 'on';
2954             if (_dMode == 'on') {
2955                 _state = 'off';
2956             }
2957             this._setDesignMode(_state);
2958             return _state;
2959         },
2960         /**
2961         * @private
2962         * @property _focused
2963         * @description Holder for trapping focus/blur state and prevent double events
2964         * @type Boolean
2965         */
2966         _focused: null,
2967         /**
2968         * @private
2969         * @method _handleFocus
2970         * @description Handles the focus of the iframe. Note, this is window focus event, not an Editor focus event.
2971         * @param {Event} e The DOM Event
2972         */
2973         _handleFocus: function(e) {
2974             if (!this._focused) {
2975                 YAHOO.log('Editor Window Focused', 'info', 'SimpleEditor');
2976                 this._focused = true;
2977                 this.fireEvent('editorWindowFocus', { type: 'editorWindowFocus', target: this });
2978             }
2979         },
2980         /**
2981         * @private
2982         * @method _handleBlur
2983         * @description Handles the blur of the iframe. Note, this is window blur event, not an Editor blur event.
2984         * @param {Event} e The DOM Event
2985         */
2986         _handleBlur: function(e) {
2987             if (this._focused) {
2988                 YAHOO.log('Editor Window Blurred', 'info', 'SimpleEditor');
2989                 this._focused = false;
2990                 this.fireEvent('editorWindowBlur', { type: 'editorWindowBlur', target: this });
2991             }
2992         },
2993         /**
2994         * @private
2995         * @method _initEditorEvents
2996         * @description This method sets up the listeners on the Editors document.
2997         */
2998         _initEditorEvents: function() {
2999             //Setup Listeners on iFrame
3000             var doc = this._getDoc(),
3001                 win = this._getWindow();
3002
3003             Event.on(doc, 'mouseup', this._handleMouseUp, this, true);
3004             Event.on(doc, 'mousedown', this._handleMouseDown, this, true);
3005             Event.on(doc, 'click', this._handleClick, this, true);
3006             Event.on(doc, 'dblclick', this._handleDoubleClick, this, true);
3007             Event.on(doc, 'keypress', this._handleKeyPress, this, true);
3008             Event.on(doc, 'keyup', this._handleKeyUp, this, true);
3009             Event.on(doc, 'keydown', this._handleKeyDown, this, true);
3010             /* TODO -- Everyone but Opera works here..
3011             Event.on(doc, 'paste', function() {
3012                 YAHOO.log('PASTE', 'info', 'SimpleEditor');
3013             }, this, true);
3014             */
3015
3016             //Focus and blur..
3017             Event.on(win, 'focus', this._handleFocus, this, true);
3018             Event.on(win, 'blur', this._handleBlur, this, true);
3019         },
3020         /**
3021         * @private
3022         * @method _removeEditorEvents
3023         * @description This method removes the listeners on the Editors document (for disabling).
3024         */
3025         _removeEditorEvents: function() {
3026             //Remove Listeners on iFrame
3027             var doc = this._getDoc(),
3028                 win = this._getWindow();
3029
3030             Event.removeListener(doc, 'mouseup', this._handleMouseUp, this, true);
3031             Event.removeListener(doc, 'mousedown', this._handleMouseDown, this, true);
3032             Event.removeListener(doc, 'click', this._handleClick, this, true);
3033             Event.removeListener(doc, 'dblclick', this._handleDoubleClick, this, true);
3034             Event.removeListener(doc, 'keypress', this._handleKeyPress, this, true);
3035             Event.removeListener(doc, 'keyup', this._handleKeyUp, this, true);
3036             Event.removeListener(doc, 'keydown', this._handleKeyDown, this, true);
3037
3038             //Focus and blur..
3039             Event.removeListener(win, 'focus', this._handleFocus, this, true);
3040             Event.removeListener(win, 'blur', this._handleBlur, this, true);
3041         },
3042         _fixWebkitDivs: function() {
3043             if (this.browser.webkit) {
3044                 var divs = this._getDoc().body.getElementsByTagName('div');
3045                 Dom.addClass(divs, 'yui-wk-div');
3046             }
3047         },
3048         /**
3049         * @private
3050         * @method _initEditor
3051         * @description This method is fired from _checkLoaded when the document is ready. It turns on designMode and set's up the listeners.
3052         */
3053         _initEditor: function() {
3054             if (this.browser.ie) {
3055                 this._getDoc().body.style.margin = '0';
3056             }
3057             if (!this.get('disabled')) {
3058                 if (this._getDoc().designMode.toLowerCase() != 'on') {
3059                     this._setDesignMode('on');
3060                     this._contentTimerCounter = 0;
3061                 }
3062             }
3063             if (!this._getDoc().body) {
3064                 YAHOO.log('Body is null, check again', 'error', 'SimpleEditor');
3065                 this._contentTimerCounter = 0;
3066                 this._checkLoaded();
3067                 return false;
3068             }
3069
3070             YAHOO.log('editorLoaded', 'info', 'SimpleEditor');
3071             this.toolbar.on('buttonClick', this._handleToolbarClick, this, true);
3072             if (!this.get('disabled')) {
3073                 this._initEditorEvents();
3074                 this.toolbar.set('disabled', false);
3075             }
3076
3077             this.fireEvent('editorContentLoaded', { type: 'editorLoaded', target: this });
3078             this._fixWebkitDivs();
3079             if (this.get('dompath')) {
3080                 YAHOO.log('Delayed DomPath write', 'info', 'SimpleEditor');
3081                 var self = this;
3082                 setTimeout(function() {
3083                     self._writeDomPath.call(self);
3084                     self._setupResize.call(self);
3085                 }, 150);
3086             }
3087             var br = [];
3088             for (var i in this.browser) {
3089                 if (this.browser[i]) {
3090                     br.push(i);
3091                 }
3092             }
3093             if (this.get('ptags')) {
3094                 br.push('ptags');
3095             }
3096             Dom.addClass(this._getDoc().body, br.join(' '));
3097             this.nodeChange(true);
3098         },
3099         /**
3100         * @private
3101         * @method _checkLoaded
3102         * @description Called from a setTimeout loop to check if the iframes body.onload event has fired, then it will init the editor.
3103         */
3104         _checkLoaded: function() {
3105             this._contentTimerCounter++;
3106             if (this._contentTimer) {
3107                 clearTimeout(this._contentTimer);
3108             }
3109             if (this._contentTimerCounter > 500) {
3110                 YAHOO.log('ERROR: Body Did Not load', 'error', 'SimpleEditor');
3111                 return false;
3112             }
3113             var init = false;
3114             try {
3115                 if (this._getDoc() && this._getDoc().body) {
3116                     if (this.browser.ie) {
3117                         if (this._getDoc().body.readyState == 'complete') {
3118                             init = true;
3119                         }
3120                     } else {
3121                         if (this._getDoc().body._rteLoaded === true) {
3122                             init = true;
3123                         }
3124                     }
3125                 }
3126             } catch (e) {
3127                 init = false;
3128                 YAHOO.log('checking body (e)' + e, 'error', 'SimpleEditor');
3129             }
3130
3131             if (init === true) {
3132                 //The onload event has fired, clean up after ourselves and fire the _initEditor method
3133                 YAHOO.log('Firing _initEditor', 'info', 'SimpleEditor');
3134                 this._initEditor();
3135             } else {
3136                 var self = this;
3137                 this._contentTimer = setTimeout(function() {
3138                     self._checkLoaded.call(self);
3139                 }, 20);
3140             }
3141         },
3142         /**
3143         * @private
3144         * @method _setInitialContent
3145         * @description This method will open the iframes content document and write the textareas value into it, then start the body.onload checking.
3146         */
3147         _setInitialContent: function() {
3148             YAHOO.log('Populating editor body with contents of the text area', 'info', 'SimpleEditor');
3149
3150             var value = ((this._textarea) ? this.get('element').value : this.get('element').innerHTML),
3151                 doc = null;
3152
3153             if ((value === '') && this.browser.gecko) {
3154                 //It seems that Gecko doesn't like an empty body so we have to give it something..
3155                 value = '<br>';
3156             }
3157
3158             var html = Lang.substitute(this.get('html'), {
3159                 TITLE: this.STR_TITLE,
3160                 CONTENT: this._cleanIncomingHTML(value),
3161                 CSS: this.get('css'),
3162                 HIDDEN_CSS: ((this.get('hiddencss')) ? this.get('hiddencss') : '/* No Hidden CSS */'),
3163                 EXTRA_CSS: ((this.get('extracss')) ? this.get('extracss') : '/* No Extra CSS */')
3164             }),
3165             check = true;
3166             if (document.compatMode != 'BackCompat') {
3167                 YAHOO.log('Adding Doctype to editable area', 'info', 'SimpleEditor');
3168                 html = this._docType + "\n" + html;
3169             } else {
3170                 YAHOO.log('DocType skipped because we are in BackCompat Mode.', 'warn', 'SimpleEditor');
3171             }
3172
3173             if (this.browser.ie || this.browser.webkit || this.browser.opera || (navigator.userAgent.indexOf('Firefox/1.5') != -1)) {
3174                 //Firefox 1.5 doesn't like setting designMode on an document created with a data url
3175                 try {
3176                     //Adobe AIR Code
3177                     if (this.browser.air) {
3178                         doc = this._getDoc().implementation.createHTMLDocument();
3179                         var origDoc = this._getDoc();
3180                         origDoc.open();
3181                         origDoc.close();
3182                         doc.open();
3183                         doc.write(html);
3184                         doc.close();
3185                         var node = origDoc.importNode(doc.getElementsByTagName("html")[0], true);
3186                         origDoc.replaceChild(node, origDoc.getElementsByTagName("html")[0]);
3187                         origDoc.body._rteLoaded = true;
3188                     } else {
3189                         doc = this._getDoc();
3190                         doc.open();
3191                         doc.write(html);
3192                         doc.close();
3193                     }
3194                 } catch (e) {
3195                     YAHOO.log('Setting doc failed.. (_setInitialContent)', 'error', 'SimpleEditor');
3196                     //Safari will only be here if we are hidden
3197                     check = false;
3198                 }
3199             } else {
3200                 //This keeps Firefox 2 from writing the iframe to history preserving the back buttons functionality
3201                 this.get('iframe').get('element').src = 'data:text/html;charset=utf-8,' + encodeURIComponent(html);
3202             }
3203             this.get('iframe').setStyle('visibility', '');
3204             if (check) {
3205                 this._checkLoaded();
3206             }
3207         },
3208         /**
3209         * @private
3210         * @method _setMarkupType
3211         * @param {String} action The action to take. Possible values are: css, default or semantic
3212         * @description This method will turn on/off the useCSS execCommand.
3213         */
3214         _setMarkupType: function(action) {
3215             switch (this.get('markup')) {
3216                 case 'css':
3217                     this._setEditorStyle(true);
3218                     break;
3219                 case 'default':
3220                     this._setEditorStyle(false);
3221                     break;
3222                 case 'semantic':
3223                 case 'xhtml':
3224                     if (this._semantic[action]) {
3225                         this._setEditorStyle(false);
3226                     } else {
3227                         this._setEditorStyle(true);
3228                     }
3229                     break;
3230             }
3231         },
3232         /**
3233         * Set the editor to use CSS instead of HTML
3234         * @param {Booleen} stat True/False
3235         */
3236         _setEditorStyle: function(stat) {
3237             try {
3238                 this._getDoc().execCommand('useCSS', false, !stat);
3239             } catch (ex) {
3240             }
3241         },
3242         /**
3243         * @private
3244         * @method _getSelectedElement
3245         * @description This method will attempt to locate the element that was last interacted with, either via selection, location or event.
3246         * @return {HTMLElement} The currently selected element.
3247         */
3248         _getSelectedElement: function() {
3249             var doc = this._getDoc(),
3250                 range = null,
3251                 sel = null,
3252                 elm = null,
3253                 check = true;
3254
3255             if (this.browser.ie) {
3256                 this.currentEvent = this._getWindow().event; //Event utility assumes window.event, so we need to reset it to this._getWindow().event;
3257                 range = this._getRange();
3258                 if (range) {
3259                     elm = range.item ? range.item(0) : range.parentElement();
3260                     if (this._hasSelection()) {
3261                         //TODO
3262                         //WTF.. Why can't I get an element reference here?!??!
3263                     }
3264                     if (elm === doc.body) {
3265                         elm = null;
3266                     }
3267                 }
3268                 if ((this.currentEvent !== null) && (this.currentEvent.keyCode === 0)) {
3269                     elm = Event.getTarget(this.currentEvent);
3270                 }
3271             } else {
3272                 sel = this._getSelection();
3273                 range = this._getRange();
3274
3275                 if (!sel || !range) {
3276                     return null;
3277                 }
3278                 //TODO
3279                 if (!this._hasSelection() && this.browser.webkit3) {
3280                     //check = false;
3281                 }
3282                 if (this.browser.gecko) {
3283                     //Added in 2.6.0
3284                     if (range.startContainer) {
3285                         if (range.startContainer.nodeType === 3) {
3286                             elm = range.startContainer.parentNode;
3287                         } else if (range.startContainer.nodeType === 1) {
3288                             elm = range.startContainer;
3289                         }
3290                         //Added in 2.7.0
3291                         if (this.currentEvent) {
3292                             var tar = Event.getTarget(this.currentEvent);
3293                             if (!this._isElement(tar, 'html')) {
3294                                 if (elm !== tar) {
3295                                     elm = tar;
3296                                 }
3297                             }
3298                         }
3299                     }
3300                 }
3301
3302                 if (check) {
3303                     if (sel.anchorNode && (sel.anchorNode.nodeType == 3)) {
3304                         if (sel.anchorNode.parentNode) { //next check parentNode
3305                             elm = sel.anchorNode.parentNode;
3306                         }
3307                         if (sel.anchorNode.nextSibling != sel.focusNode.nextSibling) {
3308                             elm = sel.anchorNode.nextSibling;
3309                         }
3310                     }
3311                     if (this._isElement(elm, 'br')) {
3312                         elm = null;
3313                     }
3314                     if (!elm) {
3315                         elm = range.commonAncestorContainer;
3316                         if (!range.collapsed) {
3317                             if (range.startContainer == range.endContainer) {
3318                                 if (range.startOffset - range.endOffset < 2) {
3319                                     if (range.startContainer.hasChildNodes()) {
3320                                         elm = range.startContainer.childNodes[range.startOffset];
3321                                     }
3322                                 }
3323                             }
3324                         }
3325                     }
3326                }
3327             }
3328
3329             if (this.currentEvent !== null) {
3330                 try {
3331                     switch (this.currentEvent.type) {
3332                         case 'click':
3333                         case 'mousedown':
3334                         case 'mouseup':
3335                             if (this.browser.webkit) {
3336                                 elm = Event.getTarget(this.currentEvent);
3337                             }
3338                             break;
3339                         default:
3340                             //Do nothing
3341                             break;
3342                     }
3343                 } catch (e) {
3344                     YAHOO.log('Firefox 1.5 errors here: ' + e, 'error', 'SimpleEditor');
3345                 }
3346             } else if ((this.currentElement && this.currentElement[0]) && (!this.browser.ie)) {
3347                 //TODO is this still needed?
3348                 //elm = this.currentElement[0];
3349             }
3350
3351
3352             if (this.browser.opera || this.browser.webkit) {
3353                 if (this.currentEvent && !elm) {
3354                     elm = YAHOO.util.Event.getTarget(this.currentEvent);
3355                 }
3356             }
3357             if (!elm || !elm.tagName) {
3358                 elm = doc.body;
3359             }
3360             if (this._isElement(elm, 'html')) {
3361                 //Safari sometimes gives us the HTML node back..
3362                 elm = doc.body;
3363             }
3364             if (this._isElement(elm, 'body')) {
3365                 //make sure that body means this body not the parent..
3366                 elm = doc.body;
3367             }
3368             if (elm && !elm.parentNode) { //Not in document
3369                 elm = doc.body;
3370             }
3371             if (elm === undefined) {
3372                 elm = null;
3373             }
3374             return elm;
3375         },
3376         /**
3377         * @private
3378         * @method _getDomPath
3379         * @description This method will attempt to build the DOM path from the currently selected element.
3380         * @param HTMLElement el The element to start with, if not provided _getSelectedElement is used
3381         * @return {Array} An array of node references that will create the DOM Path.
3382         */
3383         _getDomPath: function(el) {
3384             if (!el) {
3385                             el = this._getSelectedElement();
3386             }
3387                         var domPath = [];
3388             while (el !== null) {
3389                 if (el.ownerDocument != this._getDoc()) {
3390                     el = null;
3391                     break;
3392                 }
3393                 //Check to see if we get el.nodeName and nodeType
3394                 if (el.nodeName && el.nodeType && (el.nodeType == 1)) {
3395                     domPath[domPath.length] = el;
3396                 }
3397
3398                 if (this._isElement(el, 'body')) {
3399                     break;
3400                 }
3401
3402                 el = el.parentNode;
3403             }
3404             if (domPath.length === 0) {
3405                 if (this._getDoc() && this._getDoc().body) {
3406                     domPath[0] = this._getDoc().body;
3407                 }
3408             }
3409             return domPath.reverse();
3410         },
3411         /**
3412         * @private
3413         * @method _writeDomPath
3414         * @description Write the current DOM path out to the dompath container below the editor.
3415         */
3416         _writeDomPath: function() {
3417             var path = this._getDomPath(),
3418                 pathArr = [],
3419                 classPath = '',
3420                 pathStr = '';
3421
3422             for (var i = 0; i < path.length; i++) {
3423                 var tag = path[i].tagName.toLowerCase();
3424                 if ((tag == 'ol') && (path[i].type)) {
3425                     tag += ':' + path[i].type;
3426                 }
3427                 if (Dom.hasClass(path[i], 'yui-tag')) {
3428                     tag = path[i].getAttribute('tag');
3429                 }
3430                 if ((this.get('markup') == 'semantic') || (this.get('markup') == 'xhtml')) {
3431                     switch (tag) {
3432                         case 'b': tag = 'strong'; break;
3433                         case 'i': tag = 'em'; break;
3434                     }
3435                 }
3436                 if (!Dom.hasClass(path[i], 'yui-non')) {
3437                     if (Dom.hasClass(path[i], 'yui-tag')) {
3438                         pathStr = tag;
3439                     } else {
3440                         classPath = ((path[i].className !== '') ? '.' + path[i].className.replace(/ /g, '.') : '');
3441                         if ((classPath.indexOf('yui') != -1) || (classPath.toLowerCase().indexOf('apple-style-span') != -1)) {
3442                             classPath = '';
3443                         }
3444                         pathStr = tag + ((path[i].id) ? '#' + path[i].id : '') + classPath;
3445                     }
3446                     switch (tag) {
3447                         case 'body':
3448                             pathStr = 'body';
3449                             break;
3450                         case 'a':
3451                             if (path[i].getAttribute('href', 2)) {
3452                                 pathStr += ':' + path[i].getAttribute('href', 2).replace('mailto:', '').replace('http:/'+'/', '').replace('https:/'+'/', ''); //May need to add others here ftp
3453                             }
3454                             break;
3455                         case 'img':
3456                             var h = path[i].height;
3457                             var w = path[i].width;
3458                             if (path[i].style.height) {
3459                                 h = parseInt(path[i].style.height, 10);
3460                             }
3461                             if (path[i].style.width) {
3462                                 w = parseInt(path[i].style.width, 10);
3463                             }
3464                             pathStr += '(' + w + 'x' + h + ')';
3465                         break;
3466                     }
3467
3468                     if (pathStr.length > 10) {
3469                         pathStr = '<span title="' + pathStr + '">' + pathStr.substring(0, 10) + '...' + '</span>';
3470                     } else {
3471                         pathStr = '<span title="' + pathStr + '">' + pathStr + '</span>';
3472                     }
3473                     pathArr[pathArr.length] = pathStr;
3474                 }
3475             }
3476             var str = pathArr.join(' ' + this.SEP_DOMPATH + ' ');
3477             //Prevent flickering
3478             if (this.dompath.innerHTML != str) {
3479                 this.dompath.innerHTML = str;
3480             }
3481         },
3482         /**
3483         * @private
3484         * @method _fixNodes
3485         * @description Fix href and imgs as well as remove invalid HTML.
3486         */
3487         _fixNodes: function() {
3488             var doc = this._getDoc(),
3489                 els = [];
3490
3491             for (var v in this.invalidHTML) {
3492                 if (YAHOO.lang.hasOwnProperty(this.invalidHTML, v)) {
3493                     if (v.toLowerCase() != 'span') {
3494                         var tags = doc.body.getElementsByTagName(v);
3495                         if (tags.length) {
3496                             for (var i = 0; i < tags.length; i++) {
3497                                 els.push(tags[i]);
3498                             }
3499                         }
3500                     }
3501                 }
3502             }
3503             for (var h = 0; h < els.length; h++) {
3504                 if (els[h].parentNode) {
3505                     if (Lang.isObject(this.invalidHTML[els[h].tagName.toLowerCase()]) && this.invalidHTML[els[h].tagName.toLowerCase()].keepContents) {
3506                         this._swapEl(els[h], 'span', function(el) {
3507                             el.className = 'yui-non';
3508                         });
3509                     } else {
3510                         els[h].parentNode.removeChild(els[h]);
3511                     }
3512                 }
3513             }
3514             var imgs = this._getDoc().getElementsByTagName('img');
3515             Dom.addClass(imgs, 'yui-img');
3516         },
3517         /**
3518         * @private
3519         * @method _isNonEditable
3520         * @param Event ev The Dom event being checked
3521         * @description Method is called at the beginning of all event handlers to check if this element or a parent element has the class yui-noedit (this.CLASS_NOEDIT) applied.
3522         * If it does, then this method will stop the event and return true. The event handlers will then return false and stop the nodeChange from occuring. This method will also
3523         * disable and enable the Editor's toolbar based on the noedit state.
3524         * @return Boolean
3525         */
3526         _isNonEditable: function(ev) {
3527             if (this.get('allowNoEdit')) {
3528                 var el = Event.getTarget(ev);
3529                 if (this._isElement(el, 'html')) {
3530                     el = null;
3531                 }
3532                 var path = this._getDomPath(el);
3533                 for (var i = (path.length - 1); i > -1; i--) {
3534                     if (Dom.hasClass(path[i], this.CLASS_NOEDIT)) {
3535                         //if (this.toolbar.get('disabled') === false) {
3536                         //    this.toolbar.set('disabled', true);
3537                         //}
3538                         try {
3539                              this._getDoc().execCommand('enableObjectResizing', false, 'false');
3540                         } catch (e) {}
3541                         this.nodeChange();
3542                         Event.stopEvent(ev);
3543                         YAHOO.log('CLASS_NOEDIT found in DOM Path, stopping event', 'info', 'SimpleEditor');
3544                         return true;
3545                     }
3546                 }
3547                 //if (this.toolbar.get('disabled') === true) {
3548                     //Should only happen once..
3549                     //this.toolbar.set('disabled', false);
3550                     try {
3551                          this._getDoc().execCommand('enableObjectResizing', false, 'true');
3552                     } catch (e2) {}
3553                 //}
3554             }
3555             return false;
3556         },
3557         /**
3558         * @private
3559         * @method _setCurrentEvent
3560         * @param {Event} ev The event to cache
3561         * @description Sets the current event property
3562         */
3563         _setCurrentEvent: function(ev) {
3564             this.currentEvent = ev;
3565         },
3566         /**
3567         * @private
3568         * @method _handleClick
3569         * @param {Event} ev The event we are working on.
3570         * @description Handles all click events inside the iFrame document.
3571         */
3572         _handleClick: function(ev) {
3573             var ret = this.fireEvent('beforeEditorClick', { type: 'beforeEditorClick', target: this, ev: ev });
3574             if (ret === false) {
3575                 return false;
3576             }
3577             if (this._isNonEditable(ev)) {
3578                 return false;
3579             }
3580             this._setCurrentEvent(ev);
3581             if (this.currentWindow) {
3582                 this.closeWindow();
3583             }
3584             if (this.currentWindow) {
3585                 this.closeWindow();
3586             }
3587             if (this.browser.webkit) {
3588                 var tar =Event.getTarget(ev);
3589                 if (this._isElement(tar, 'a') || this._isElement(tar.parentNode, 'a')) {
3590                     Event.stopEvent(ev);
3591                     this.nodeChange();
3592                 }
3593             } else {
3594                 this.nodeChange();
3595             }
3596             this.fireEvent('editorClick', { type: 'editorClick', target: this, ev: ev });
3597         },
3598         /**
3599         * @private
3600         * @method _handleMouseUp
3601         * @param {Event} ev The event we are working on.
3602         * @description Handles all mouseup events inside the iFrame document.
3603         */
3604         _handleMouseUp: function(ev) {
3605             var ret = this.fireEvent('beforeEditorMouseUp', { type: 'beforeEditorMouseUp', target: this, ev: ev });
3606             if (ret === false) {
3607                 return false;
3608             }
3609             if (this._isNonEditable(ev)) {
3610                 return false;
3611             }
3612             //Don't set current event for mouseup.
3613             //It get's fired after a menu is closed and gives up a bogus event to work with
3614             //this._setCurrentEvent(ev);
3615             var self = this;
3616             if (this.browser.opera) {
3617                 /*
3618                 * @knownissue Opera appears to stop the MouseDown, Click and DoubleClick events on an image inside of a document with designMode on..
3619                 * @browser Opera
3620                 * @description This work around traps the MouseUp event and sets a timer to check if another MouseUp event fires in so many seconds. If another event is fired, they we internally fire the DoubleClick event.
3621                 */
3622                 var sel = Event.getTarget(ev);
3623                 if (this._isElement(sel, 'img')) {
3624                     this.nodeChange();
3625                     if (this.operaEvent) {
3626                         clearTimeout(this.operaEvent);
3627                         this.operaEvent = null;
3628                         this._handleDoubleClick(ev);
3629                     } else {
3630                         this.operaEvent = window.setTimeout(function() {
3631                             self.operaEvent = false;
3632                         }, 700);
3633                     }
3634                 }
3635             }
3636             //This will stop Safari from selecting the entire document if you select all the text in the editor
3637             if (this.browser.webkit || this.browser.opera) {
3638                 if (this.browser.webkit) {
3639                     Event.stopEvent(ev);
3640                 }
3641             }
3642             this.nodeChange();
3643             this.fireEvent('editorMouseUp', { type: 'editorMouseUp', target: this, ev: ev });
3644         },
3645         /**
3646         * @private
3647         * @method _handleMouseDown
3648         * @param {Event} ev The event we are working on.
3649         * @description Handles all mousedown events inside the iFrame document.
3650         */
3651         _handleMouseDown: function(ev) {
3652             var ret = this.fireEvent('beforeEditorMouseDown', { type: 'beforeEditorMouseDown', target: this, ev: ev });
3653             if (ret === false) {
3654                 return false;
3655             }
3656             if (this._isNonEditable(ev)) {
3657                 return false;
3658             }
3659             this._setCurrentEvent(ev);
3660             var sel = Event.getTarget(ev);
3661             if (this.browser.webkit && this._hasSelection()) {
3662                 var _sel = this._getSelection();
3663                 if (!this.browser.webkit3) {
3664                     _sel.collapse(true);
3665                 } else {
3666                     _sel.collapseToStart();
3667                 }
3668             }
3669             if (this.browser.webkit && this._lastImage) {
3670                 Dom.removeClass(this._lastImage, 'selected');
3671                 this._lastImage = null;
3672             }
3673             if (this._isElement(sel, 'img') || this._isElement(sel, 'a')) {
3674                 if (this.browser.webkit) {
3675                     Event.stopEvent(ev);
3676                     if (this._isElement(sel, 'img')) {
3677                         Dom.addClass(sel, 'selected');
3678                         this._lastImage = sel;
3679                     }
3680                 }
3681                 if (this.currentWindow) {
3682                     this.closeWindow();
3683                 }
3684                 this.nodeChange();
3685             }
3686             this.fireEvent('editorMouseDown', { type: 'editorMouseDown', target: this, ev: ev });
3687         },
3688         /**
3689         * @private
3690         * @method _handleDoubleClick
3691         * @param {Event} ev The event we are working on.
3692         * @description Handles all doubleclick events inside the iFrame document.
3693         */
3694         _handleDoubleClick: function(ev) {
3695             var ret = this.fireEvent('beforeEditorDoubleClick', { type: 'beforeEditorDoubleClick', target: this, ev: ev });
3696             if (ret === false) {
3697                 return false;
3698             }
3699             if (this._isNonEditable(ev)) {
3700                 return false;
3701             }
3702             this._setCurrentEvent(ev);
3703             var sel = Event.getTarget(ev);
3704             if (this._isElement(sel, 'img')) {
3705                 this.currentElement[0] = sel;
3706                 this.toolbar.fireEvent('insertimageClick', { type: 'insertimageClick', target: this.toolbar });
3707                 this.fireEvent('afterExecCommand', { type: 'afterExecCommand', target: this });
3708             } else if (this._hasParent(sel, 'a')) { //Handle elements inside an a
3709                 this.currentElement[0] = this._hasParent(sel, 'a');
3710                 this.toolbar.fireEvent('createlinkClick', { type: 'createlinkClick', target: this.toolbar });
3711                 this.fireEvent('afterExecCommand', { type: 'afterExecCommand', target: this });
3712             }
3713             this.nodeChange();
3714             this.fireEvent('editorDoubleClick', { type: 'editorDoubleClick', target: this, ev: ev });
3715         },
3716         /**
3717         * @private
3718         * @method _handleKeyUp
3719         * @param {Event} ev The event we are working on.
3720         * @description Handles all keyup events inside the iFrame document.
3721         */
3722         _handleKeyUp: function(ev) {
3723             var ret = this.fireEvent('beforeEditorKeyUp', { type: 'beforeEditorKeyUp', target: this, ev: ev });
3724             if (ret === false) {
3725                 return false;
3726             }
3727             if (this._isNonEditable(ev)) {
3728                 return false;
3729             }
3730             this._setCurrentEvent(ev);
3731             switch (ev.keyCode) {
3732                 case this._keyMap.SELECT_ALL.key:
3733                     if (this._checkKey(this._keyMap.SELECT_ALL, ev)) {
3734                         this.nodeChange();
3735                     }
3736                     break;
3737                 case 32: //Space Bar
3738                 case 35: //End
3739                 case 36: //Home
3740                 case 37: //Left Arrow
3741                 case 38: //Up Arrow
3742                 case 39: //Right Arrow
3743                 case 40: //Down Arrow
3744                 case 46: //Forward Delete
3745                 case 8: //Delete
3746                 case this._keyMap.CLOSE_WINDOW.key: //W key if window is open
3747                     if ((ev.keyCode == this._keyMap.CLOSE_WINDOW.key) && this.currentWindow) {
3748                         if (this._checkKey(this._keyMap.CLOSE_WINDOW, ev)) {
3749                             this.closeWindow();
3750                         }
3751                     } else {
3752                         if (!this.browser.ie) {
3753                             if (this._nodeChangeTimer) {
3754                                 clearTimeout(this._nodeChangeTimer);
3755                             }
3756                             var self = this;
3757                             this._nodeChangeTimer = setTimeout(function() {
3758                                 self._nodeChangeTimer = null;
3759                                 self.nodeChange.call(self);
3760                             }, 100);
3761                         } else {
3762                             this.nodeChange();
3763                         }
3764                         this.editorDirty = true;
3765                     }
3766                     break;
3767             }
3768             this.fireEvent('editorKeyUp', { type: 'editorKeyUp', target: this, ev: ev });
3769             this._storeUndo();
3770         },
3771         /**
3772         * @private
3773         * @method _handleKeyPress
3774         * @param {Event} ev The event we are working on.
3775         * @description Handles all keypress events inside the iFrame document.
3776         */
3777         _handleKeyPress: function(ev) {
3778             var ret = this.fireEvent('beforeEditorKeyPress', { type: 'beforeEditorKeyPress', target: this, ev: ev });
3779             if (ret === false) {
3780                 return false;
3781             }
3782
3783             if (this.get('allowNoEdit')) {
3784                 //if (ev && ev.keyCode && ((ev.keyCode == 46) || ev.keyCode == 63272)) {
3785                 if (ev && ev.keyCode && (ev.keyCode == 63272)) {
3786                     //Forward delete key
3787                     YAHOO.log('allowNoEdit is set, forward delete key has been disabled', 'warn', 'SimpleEditor');
3788                     Event.stopEvent(ev);
3789                 }
3790             }
3791             if (this._isNonEditable(ev)) {
3792                 return false;
3793             }
3794             this._setCurrentEvent(ev);
3795             if (this.browser.opera) {
3796                 if (ev.keyCode === 13) {
3797                     var tar = this._getSelectedElement();
3798                     if (!this._isElement(tar, 'li')) {
3799                         this.execCommand('inserthtml', '<br>');
3800                         Event.stopEvent(ev);
3801                     }
3802                 }
3803             }
3804             if (this.browser.webkit) {
3805                 if (!this.browser.webkit3) {
3806                     if (ev.keyCode && (ev.keyCode == 122) && (ev.metaKey)) {
3807                         //This is CMD + z (for undo)
3808                         if (this._hasParent(this._getSelectedElement(), 'li')) {
3809                             YAHOO.log('We are in an LI and we found CMD + z, stopping the event', 'warn', 'SimpleEditor');
3810                             Event.stopEvent(ev);
3811                         }
3812                     }
3813                 }
3814                 this._listFix(ev);
3815             }
3816             this.fireEvent('editorKeyPress', { type: 'editorKeyPress', target: this, ev: ev });
3817         },
3818         /**
3819         * @private
3820         * @method _handleKeyDown
3821         * @param {Event} ev The event we are working on.
3822         * @description Handles all keydown events inside the iFrame document.
3823         */
3824         _handleKeyDown: function(ev) {
3825             var ret = this.fireEvent('beforeEditorKeyDown', { type: 'beforeEditorKeyDown', target: this, ev: ev });
3826             if (ret === false) {
3827                 return false;
3828             }
3829             var tar = null, _range = null;
3830             if (this._isNonEditable(ev)) {
3831                 return false;
3832             }
3833             this._setCurrentEvent(ev);
3834             if (this.currentWindow) {
3835                 this.closeWindow();
3836             }
3837             if (this.currentWindow) {
3838                 this.closeWindow();
3839             }
3840             var doExec = false,
3841                 action = null,
3842                 value = null,
3843                 exec = false;
3844
3845             //YAHOO.log('keyCode: ' + ev.keyCode, 'info', 'SimpleEditor');
3846
3847             switch (ev.keyCode) {
3848                 case this._keyMap.FOCUS_TOOLBAR.key:
3849                     if (this._checkKey(this._keyMap.FOCUS_TOOLBAR, ev)) {
3850                         var h = this.toolbar.getElementsByTagName('h2')[0];
3851                         if (h && h.firstChild) {
3852                             h.firstChild.focus();
3853                         }
3854                     } else if (this._checkKey(this._keyMap.FOCUS_AFTER, ev)) {
3855                         //Focus After Element - Esc
3856                         this.afterElement.focus();
3857                     }
3858                     Event.stopEvent(ev);
3859                     doExec = false;
3860                     break;
3861                 //case 76: //L
3862                 case this._keyMap.CREATE_LINK.key: //L
3863                     if (this._hasSelection()) {
3864                         if (this._checkKey(this._keyMap.CREATE_LINK, ev)) {
3865                             var makeLink = true;
3866                             if (this.get('limitCommands')) {
3867                                 if (!this.toolbar.getButtonByValue('createlink')) {
3868                                     YAHOO.log('Toolbar Button for (createlink) was not found, skipping exec.', 'info', 'SimpleEditor');
3869                                     makeLink = false;
3870                                 }
3871                             }
3872                             if (makeLink) {
3873                                 this.execCommand('createlink', '');
3874                                 this.toolbar.fireEvent('createlinkClick', { type: 'createlinkClick', target: this.toolbar });
3875                                 this.fireEvent('afterExecCommand', { type: 'afterExecCommand', target: this });
3876                                 doExec = false;
3877                             }
3878                         }
3879                     }
3880                     break;
3881                 //case 90: //Z
3882                 case this._keyMap.UNDO.key:
3883                 case this._keyMap.REDO.key:
3884                     if (this._checkKey(this._keyMap.REDO, ev)) {
3885                         action = 'redo';
3886                         doExec = true;
3887                     } else if (this._checkKey(this._keyMap.UNDO, ev)) {
3888                         action = 'undo';
3889                         doExec = true;
3890                     }
3891                     break;
3892                 //case 66: //B
3893                 case this._keyMap.BOLD.key:
3894                     if (this._checkKey(this._keyMap.BOLD, ev)) {
3895                         action = 'bold';
3896                         doExec = true;
3897                     }
3898                     break;
3899                 case this._keyMap.FONT_SIZE_UP.key:
3900                 case this._keyMap.FONT_SIZE_DOWN.key:
3901                     var uk = false, dk = false;
3902                     if (this._checkKey(this._keyMap.FONT_SIZE_UP, ev)) {
3903                         uk = true;
3904                     }
3905                     if (this._checkKey(this._keyMap.FONT_SIZE_DOWN, ev)) {
3906                         dk = true;
3907                     }
3908                     if (uk || dk) {
3909                         var fs_button = this.toolbar.getButtonByValue('fontsize'),
3910                             label = parseInt(fs_button.get('label'), 10),
3911                             newValue = (label + 1);
3912
3913                         if (dk) {
3914                             newValue = (label - 1);
3915                         }
3916
3917                         action = 'fontsize';
3918                         value = newValue + 'px';
3919                         doExec = true;
3920                     }
3921                     break;
3922                 //case 73: //I
3923                 case this._keyMap.ITALIC.key:
3924                     if (this._checkKey(this._keyMap.ITALIC, ev)) {
3925                         action = 'italic';
3926                         doExec = true;
3927                     }
3928                     break;
3929                 //case 85: //U
3930                 case this._keyMap.UNDERLINE.key:
3931                     if (this._checkKey(this._keyMap.UNDERLINE, ev)) {
3932                         action = 'underline';
3933                         doExec = true;
3934                     }
3935                     break;
3936                 case 9:
3937                     if (this.browser.ie) {
3938                         //Insert a tab in Internet Explorer
3939                         _range = this._getRange();
3940                         tar = this._getSelectedElement();
3941                         if (!this._isElement(tar, 'li')) {
3942                             if (_range) {
3943                                 _range.pasteHTML('&nbsp;&nbsp;&nbsp;&nbsp;');
3944                                 _range.collapse(false);
3945                                 _range.select();
3946                             }
3947                             Event.stopEvent(ev);
3948                         }
3949                     }
3950                     //Firefox 3 code
3951                     if (this.browser.gecko > 1.8) {
3952                         tar = this._getSelectedElement();
3953                         if (this._isElement(tar, 'li')) {
3954                             if (ev.shiftKey) {
3955                                 this._getDoc().execCommand('outdent', null, '');
3956                             } else {
3957                                 this._getDoc().execCommand('indent', null, '');
3958                             }
3959
3960                         } else if (!this._hasSelection()) {
3961                             this.execCommand('inserthtml', '&nbsp;&nbsp;&nbsp;&nbsp;');
3962                         }
3963                         Event.stopEvent(ev);
3964                     }
3965                     break;
3966                 case 13:
3967                     var p = null, i = 0;
3968                     if (this.get('ptags') && !ev.shiftKey) {
3969                         if (this.browser.gecko) {
3970                             tar = this._getSelectedElement();
3971                             if (!this._hasParent(tar, 'li')) {
3972                                 if (this._hasParent(tar, 'p')) {
3973                                     p = this._getDoc().createElement('p');
3974                                     p.innerHTML = '&nbsp;';
3975                                     Dom.insertAfter(p, tar);
3976                                     this._selectNode(p.firstChild);
3977                                 } else if (this._isElement(tar, 'body')) {
3978                                     this.execCommand('insertparagraph', null);
3979                                     var ps = this._getDoc().body.getElementsByTagName('p');
3980                                     for (i = 0; i < ps.length; i++) {
3981                                         if (ps[i].getAttribute('_moz_dirty') !== null) {
3982                                             p = this._getDoc().createElement('p');
3983                                             p.innerHTML = '&nbsp;';
3984                                             Dom.insertAfter(p, ps[i]);
3985                                             this._selectNode(p.firstChild);
3986                                             ps[i].removeAttribute('_moz_dirty');
3987                                         }
3988                                     }
3989                                 } else {
3990                                     YAHOO.log('Something went wrong with paragraphs, please file a bug!!', 'error', 'SimpleEditor');
3991                                     doExec = true;
3992                                     action = 'insertparagraph';
3993                                 }
3994                                 Event.stopEvent(ev);
3995                             }
3996                         }
3997                         if (this.browser.webkit) {
3998                             tar = this._getSelectedElement();
3999                             if (!this._hasParent(tar, 'li')) {
4000                                 this.execCommand('insertparagraph', null);
4001                                 var divs = this._getDoc().body.getElementsByTagName('div');
4002                                 for (i = 0; i < divs.length; i++) {
4003                                     if (!Dom.hasClass(divs[i], 'yui-wk-div')) {
4004                                         Dom.addClass(divs[i], 'yui-wk-p');
4005                                     }
4006                                 }
4007                                 Event.stopEvent(ev);
4008                             }
4009                         }
4010                     } else {
4011                         if (this.browser.webkit) {
4012                             tar = this._getSelectedElement();
4013                             if (!this._hasParent(tar, 'li')) {
4014                                 this.execCommand('inserthtml', '<var id="yui-br"></var>');
4015                                 var holder = this._getDoc().getElementById('yui-br'),
4016                                     br = this._getDoc().createElement('br'),
4017                                     caret = this._getDoc().createElement('span');
4018
4019                                 holder.parentNode.replaceChild(br, holder);
4020                                 caret.className = 'yui-non';
4021                                 caret.innerHTML = '&nbsp;';
4022                                 Dom.insertAfter(caret, br);
4023                                 this._selectNode(caret);
4024                                 Event.stopEvent(ev);
4025                             }
4026                         }
4027                         if (this.browser.ie) {
4028                             YAHOO.log('Stopping P tags', 'info', 'SimpleEditor');
4029                             //Insert a <br> instead of a <p></p> in Internet Explorer
4030                             _range = this._getRange();
4031                             tar = this._getSelectedElement();
4032                             if (!this._isElement(tar, 'li')) {
4033                                 if (_range) {
4034                                     _range.pasteHTML('<br>');
4035                                     _range.collapse(false);
4036                                     _range.select();
4037                                 }
4038                                 Event.stopEvent(ev);
4039                             }
4040                         }
4041                     }
4042                     break;
4043             }
4044             if (this.browser.ie) {
4045                 this._listFix(ev);
4046             }
4047             if (doExec && action) {
4048                 this.execCommand(action, value);
4049                 Event.stopEvent(ev);
4050                 this.nodeChange();
4051             }
4052             this.fireEvent('editorKeyDown', { type: 'editorKeyDown', target: this, ev: ev });
4053         },
4054         /**
4055         * @private
4056         * @method _listFix
4057         * @param {Event} ev The event we are working on.
4058         * @description Handles the Enter key, Tab Key and Shift + Tab keys for List Items.
4059         */
4060         _listFix: function(ev) {
4061             //YAHOO.log('Lists Fix (' + ev.keyCode + ')', 'info', 'SimpleEditor');
4062             var testLi = null, par = null, preContent = false, range = null;
4063             //Enter Key
4064             if (this.browser.webkit) {
4065                 if (ev.keyCode && (ev.keyCode == 13)) {
4066                     if (this._hasParent(this._getSelectedElement(), 'li')) {
4067                         var tar = this._hasParent(this._getSelectedElement(), 'li');
4068                         if (tar.previousSibling) {
4069                             if (tar.firstChild && (tar.firstChild.length == 1)) {
4070                                 this._selectNode(tar);
4071                             }
4072                         }
4073                     }
4074                 }
4075             }
4076             //Shift + Tab Key
4077             if (ev.keyCode && ((!this.browser.webkit3 && (ev.keyCode == 25)) || ((this.browser.webkit3 || !this.browser.webkit) && ((ev.keyCode == 9) && ev.shiftKey)))) {
4078                 testLi = this._getSelectedElement();
4079                 if (this._hasParent(testLi, 'li')) {
4080                     testLi = this._hasParent(testLi, 'li');
4081                     YAHOO.log('We have a SHIFT tab in an LI, reverse it..', 'info', 'SimpleEditor');
4082                     if (this._hasParent(testLi, 'ul') || this._hasParent(testLi, 'ol')) {
4083                         YAHOO.log('We have a double parent, move up a level', 'info', 'SimpleEditor');
4084                         par = this._hasParent(testLi, 'ul');
4085                         if (!par) {
4086                             par = this._hasParent(testLi, 'ol');
4087                         }
4088                         //YAHOO.log(par.previousSibling + ' :: ' + par.previousSibling.innerHTML);
4089                         if (this._isElement(par.previousSibling, 'li')) {
4090                             par.removeChild(testLi);
4091                             par.parentNode.insertBefore(testLi, par.nextSibling);
4092                             if (this.browser.ie) {
4093                                 range = this._getDoc().body.createTextRange();
4094                                 range.moveToElementText(testLi);
4095                                 range.collapse(false);
4096                                 range.select();
4097                             }
4098                             if (this.browser.webkit) {
4099                                 this._selectNode(testLi.firstChild);
4100                             }
4101                             Event.stopEvent(ev);
4102                         }
4103                     }
4104                 }
4105             }
4106             //Tab Key
4107             if (ev.keyCode && ((ev.keyCode == 9) && (!ev.shiftKey))) {
4108                 YAHOO.log('List Fix - Tab', 'info', 'SimpleEditor');
4109                 var preLi = this._getSelectedElement();
4110                 if (this._hasParent(preLi, 'li')) {
4111                     preContent = this._hasParent(preLi, 'li').innerHTML;
4112                 }
4113                 //YAHOO.log('preLI: ' + preLi.tagName + ' :: ' + preLi.innerHTML);
4114                 if (this.browser.webkit) {
4115                     this._getDoc().execCommand('inserttext', false, '\t');
4116                 }
4117                 testLi = this._getSelectedElement();
4118                 if (this._hasParent(testLi, 'li')) {
4119                     YAHOO.log('We have a tab in an LI', 'info', 'SimpleEditor');
4120                     par = this._hasParent(testLi, 'li');
4121                     YAHOO.log('parLI: ' + par.tagName + ' :: ' + par.innerHTML);
4122                     var newUl = this._getDoc().createElement(par.parentNode.tagName.toLowerCase());
4123                     if (this.browser.webkit) {
4124                         var span = Dom.getElementsByClassName('Apple-tab-span', 'span', par);
4125                         //Remove the span element that Safari puts in
4126                         if (span[0]) {
4127                             par.removeChild(span[0]);
4128                             par.innerHTML = Lang.trim(par.innerHTML);
4129                             //Put the HTML from the LI into this new LI
4130                             if (preContent) {
4131                                 par.innerHTML = '<span class="yui-non">' + preContent + '</span>&nbsp;';
4132                             } else {
4133                                 par.innerHTML = '<span class="yui-non">&nbsp;</span>&nbsp;';
4134                             }
4135                         }
4136                     } else {
4137                         if (preContent) {
4138                             par.innerHTML = preContent + '&nbsp;';
4139                         } else {
4140                             par.innerHTML = '&nbsp;';
4141                         }
4142                     }
4143
4144                     par.parentNode.replaceChild(newUl, par);
4145                     newUl.appendChild(par);
4146                     if (this.browser.webkit) {
4147                         this._getSelection().setBaseAndExtent(par.firstChild, 1, par.firstChild, par.firstChild.innerText.length);
4148                         if (!this.browser.webkit3) {
4149                             par.parentNode.parentNode.style.display = 'list-item';
4150                             setTimeout(function() {
4151                                 par.parentNode.parentNode.style.display = 'block';
4152                             }, 1);
4153                         }
4154                     } else if (this.browser.ie) {
4155                         range = this._getDoc().body.createTextRange();
4156                         range.moveToElementText(par);
4157                         range.collapse(false);
4158                         range.select();
4159                     } else {
4160                         this._selectNode(par);
4161                     }
4162                     Event.stopEvent(ev);
4163                 }
4164                 if (this.browser.webkit) {
4165                     Event.stopEvent(ev);
4166                 }
4167                 this.nodeChange();
4168             }
4169         },
4170         /**
4171         * @method nodeChange
4172         * @param {Boolean} force Optional paramenter to skip the threshold counter
4173         * @description Handles setting up the toolbar buttons, getting the Dom path, fixing nodes.
4174         */
4175         nodeChange: function(force) {
4176             var NCself = this;
4177             this._storeUndo();
4178             if (this.get('nodeChangeDelay')) {
4179                 window.setTimeout(function() {
4180                     NCself._nodeChange.apply(NCself, arguments);
4181                 }, 0);
4182             } else {
4183                 this._nodeChange();
4184             }
4185         },
4186         /**
4187         * @private
4188         * @method _nodeChange
4189         * @param {Boolean} force Optional paramenter to skip the threshold counter
4190         * @description Fired from nodeChange in a setTimeout.
4191         */
4192         _nodeChange: function(force) {
4193             var threshold = parseInt(this.get('nodeChangeThreshold'), 10),
4194                 thisNodeChange = Math.round(new Date().getTime() / 1000),
4195                 self = this;
4196
4197             if (force === true) {
4198                 this._lastNodeChange = 0;
4199             }
4200
4201             if ((this._lastNodeChange + threshold) < thisNodeChange) {
4202                 if (this._fixNodesTimer === null) {
4203                     this._fixNodesTimer = window.setTimeout(function() {
4204                         self._fixNodes.call(self);
4205                         self._fixNodesTimer = null;
4206                     }, 0);
4207                 }
4208             }
4209             this._lastNodeChange = thisNodeChange;
4210             if (this.currentEvent) {
4211                 try {
4212                     this._lastNodeChangeEvent = this.currentEvent.type;
4213                 } catch (e) {}
4214             }
4215
4216             var beforeNodeChange = this.fireEvent('beforeNodeChange', { type: 'beforeNodeChange', target: this });
4217             if (beforeNodeChange === false) {
4218                 return false;
4219             }
4220             if (this.get('dompath')) {
4221                 window.setTimeout(function() {
4222                     self._writeDomPath.call(self);
4223                 }, 0);
4224             }
4225             //Check to see if we are disabled before continuing
4226             if (!this.get('disabled')) {
4227                 if (this.STOP_NODE_CHANGE) {
4228                     //Reset this var for next action
4229                     this.STOP_NODE_CHANGE = false;
4230                     return false;
4231                 } else {
4232                     var sel = this._getSelection(),
4233                         range = this._getRange(),
4234                         el = this._getSelectedElement(),
4235                         fn_button = this.toolbar.getButtonByValue('fontname'),
4236                         fs_button = this.toolbar.getButtonByValue('fontsize'),
4237                         undo_button = this.toolbar.getButtonByValue('undo'),
4238                         redo_button = this.toolbar.getButtonByValue('redo');
4239
4240                     //Handle updating the toolbar with active buttons
4241                     var _ex = {};
4242                     if (this._lastButton) {
4243                         _ex[this._lastButton.id] = true;
4244                         //this._lastButton = null;
4245                     }
4246                     if (!this._isElement(el, 'body')) {
4247                         if (fn_button) {
4248                             _ex[fn_button.get('id')] = true;
4249                         }
4250                         if (fs_button) {
4251                             _ex[fs_button.get('id')] = true;
4252                         }
4253                     }
4254                     if (redo_button) {
4255                         delete _ex[redo_button.get('id')];
4256                     }
4257                     this.toolbar.resetAllButtons(_ex);
4258
4259                     //Handle disabled buttons
4260                     for (var d = 0; d < this._disabled.length; d++) {
4261                         var _button = this.toolbar.getButtonByValue(this._disabled[d]);
4262                         if (_button && _button.get) {
4263                             if (this._lastButton && (_button.get('id') === this._lastButton.id)) {
4264                                 //Skip
4265                             } else {
4266                                 if (!this._hasSelection() && !this.get('insert')) {
4267                                     switch (this._disabled[d]) {
4268                                         case 'fontname':
4269                                         case 'fontsize':
4270                                             break;
4271                                         default:
4272                                             //No Selection - disable
4273                                             this.toolbar.disableButton(_button);
4274                                     }
4275                                 } else {
4276                                     if (!this._alwaysDisabled[this._disabled[d]]) {
4277                                         this.toolbar.enableButton(_button);
4278                                     }
4279                                 }
4280                                 if (!this._alwaysEnabled[this._disabled[d]]) {
4281                                     this.toolbar.deselectButton(_button);
4282                                 }
4283                             }
4284                         }
4285                     }
4286                     var path = this._getDomPath();
4287                     var tag = null, cmd = null;
4288                     for (var i = 0; i < path.length; i++) {
4289                         tag = path[i].tagName.toLowerCase();
4290                         if (path[i].getAttribute('tag')) {
4291                             tag = path[i].getAttribute('tag').toLowerCase();
4292                         }
4293                         cmd = this._tag2cmd[tag];
4294                         if (cmd === undefined) {
4295                             cmd = [];
4296                         }
4297                         if (!Lang.isArray(cmd)) {
4298                             cmd = [cmd];
4299                         }
4300
4301                         //Bold and Italic styles
4302                         if (path[i].style.fontWeight.toLowerCase() == 'bold') {
4303                             cmd[cmd.length] = 'bold';
4304                         }
4305                         if (path[i].style.fontStyle.toLowerCase() == 'italic') {
4306                             cmd[cmd.length] = 'italic';
4307                         }
4308                         if (path[i].style.textDecoration.toLowerCase() == 'underline') {
4309                             cmd[cmd.length] = 'underline';
4310                         }
4311                         if (path[i].style.textDecoration.toLowerCase() == 'line-through') {
4312                             cmd[cmd.length] = 'strikethrough';
4313                         }
4314                         if (cmd.length > 0) {
4315                             for (var j = 0; j < cmd.length; j++) {
4316                                 this.toolbar.selectButton(cmd[j]);
4317                                 this.toolbar.enableButton(cmd[j]);
4318                             }
4319                         }
4320                         //Handle Alignment
4321                         switch (path[i].style.textAlign.toLowerCase()) {
4322                             case 'left':
4323                             case 'right':
4324                             case 'center':
4325                             case 'justify':
4326                                 var alignType = path[i].style.textAlign.toLowerCase();
4327                                 if (path[i].style.textAlign.toLowerCase() == 'justify') {
4328                                     alignType = 'full';
4329                                 }
4330                                 this.toolbar.selectButton('justify' + alignType);
4331                                 this.toolbar.enableButton('justify' + alignType);
4332                                 break;
4333                         }
4334                     }
4335                     //After for loop
4336
4337                     //Reset Font Family and Size to the inital configs
4338                     if (fn_button) {
4339                         var family = fn_button._configs.label._initialConfig.value;
4340                         fn_button.set('label', '<span class="yui-toolbar-fontname-' + this._cleanClassName(family) + '">' + family + '</span>');
4341                         this._updateMenuChecked('fontname', family);
4342                     }
4343
4344                     if (fs_button) {
4345                         fs_button.set('label', fs_button._configs.label._initialConfig.value);
4346                     }
4347
4348                     var hd_button = this.toolbar.getButtonByValue('heading');
4349                     if (hd_button) {
4350                         hd_button.set('label', hd_button._configs.label._initialConfig.value);
4351                         this._updateMenuChecked('heading', 'none');
4352                     }
4353                     var img_button = this.toolbar.getButtonByValue('insertimage');
4354                     if (img_button && this.currentWindow && (this.currentWindow.name == 'insertimage')) {
4355                         this.toolbar.disableButton(img_button);
4356                     }
4357                     if (this._lastButton && this._lastButton.isSelected) {
4358                         this.toolbar.deselectButton(this._lastButton.id);
4359                     }
4360                     this._undoNodeChange();
4361                 }
4362             }
4363
4364             this.fireEvent('afterNodeChange', { type: 'afterNodeChange', target: this });
4365         },
4366         /**
4367         * @private
4368         * @method _updateMenuChecked
4369         * @param {Object} button The command identifier of the button you want to check
4370         * @param {String} value The value of the menu item you want to check
4371         * @param {<a href="YAHOO.widget.Toolbar.html">YAHOO.widget.Toolbar</a>} The Toolbar instance the button belongs to (defaults to this.toolbar)
4372         * @description Gets the menu from a button instance, if the menu is not rendered it will render it. It will then search the menu for the specified value, unchecking all other items and checking the specified on.
4373         */
4374         _updateMenuChecked: function(button, value, tbar) {
4375             if (!tbar) {
4376                 tbar = this.toolbar;
4377             }
4378             var _button = tbar.getButtonByValue(button);
4379             _button.checkValue(value);
4380         },
4381         /**
4382         * @private
4383         * @method _handleToolbarClick
4384         * @param {Event} ev The event that triggered the button click
4385         * @description This is an event handler attached to the Toolbar's buttonClick event. It will fire execCommand with the command identifier from the Toolbar Button.
4386         */
4387         _handleToolbarClick: function(ev) {
4388             var value = '';
4389             var str = '';
4390             var cmd = ev.button.value;
4391             if (ev.button.menucmd) {
4392                 value = cmd;
4393                 cmd = ev.button.menucmd;
4394             }
4395             this._lastButton = ev.button;
4396             if (this.STOP_EXEC_COMMAND) {
4397                 YAHOO.log('execCommand skipped because we found the STOP_EXEC_COMMAND flag set to true', 'warn', 'SimpleEditor');
4398                 YAHOO.log('NOEXEC::execCommand::(' + cmd + '), (' + value + ')', 'warn', 'SimpleEditor');
4399                 this.STOP_EXEC_COMMAND = false;
4400                 return false;
4401             } else {
4402                 this.execCommand(cmd, value);
4403                 if (!this.browser.webkit) {
4404                      var Fself = this;
4405                      setTimeout(function() {
4406                          Fself.focus.call(Fself);
4407                      }, 5);
4408                  }
4409             }
4410             Event.stopEvent(ev);
4411         },
4412         /**
4413         * @private
4414         * @method _setupAfterElement
4415         * @description Creates the accessibility h2 header and places it after the iframe in the Dom for navigation.
4416         */
4417         _setupAfterElement: function() {
4418             if (!this.beforeElement) {
4419                 this.beforeElement = document.createElement('h2');
4420                 this.beforeElement.className = 'yui-editor-skipheader';
4421                 this.beforeElement.tabIndex = '-1';
4422                 this.beforeElement.innerHTML = this.STR_BEFORE_EDITOR;
4423                 this.get('element_cont').get('firstChild').insertBefore(this.beforeElement, this.toolbar.get('nextSibling'));
4424             }
4425             if (!this.afterElement) {
4426                 this.afterElement = document.createElement('h2');
4427                 this.afterElement.className = 'yui-editor-skipheader';
4428                 this.afterElement.tabIndex = '-1';
4429                 this.afterElement.innerHTML = this.STR_LEAVE_EDITOR;
4430                 this.get('element_cont').get('firstChild').appendChild(this.afterElement);
4431             }
4432         },
4433         /**
4434         * @private
4435         * @method _disableEditor
4436         * @param {Boolean} disabled Pass true to disable, false to enable
4437         * @description Creates a mask to place over the Editor.
4438         */
4439         _disableEditor: function(disabled) {
4440             if (disabled) {
4441                 this._removeEditorEvents();
4442                 if (!this._mask) {
4443                     if (!!this.browser.ie) {
4444                         this._setDesignMode('off');
4445                     }
4446                     if (this.toolbar) {
4447                         this.toolbar.set('disabled', true);
4448                     }
4449                     this._mask = document.createElement('DIV');
4450                     Dom.addClass(this._mask, 'yui-editor-masked');
4451                     this.get('iframe').get('parentNode').appendChild(this._mask);
4452                 }
4453             } else {
4454                 this._initEditorEvents();
4455                 if (this._mask) {
4456                     this._mask.parentNode.removeChild(this._mask);
4457                     this._mask = null;
4458                     if (this.toolbar) {
4459                         this.toolbar.set('disabled', false);
4460                     }
4461                     this._setDesignMode('on');
4462                     this.focus();
4463                     var self = this;
4464                     window.setTimeout(function() {
4465                         self.nodeChange.call(self);
4466                     }, 100);
4467                 }
4468             }
4469         },
4470         /**
4471         * @property SEP_DOMPATH
4472         * @description The value to place in between the Dom path items
4473         * @type String
4474         */
4475         SEP_DOMPATH: '<',
4476         /**
4477         * @property STR_LEAVE_EDITOR
4478         * @description The accessibility string for the element after the iFrame
4479         * @type String
4480         */
4481         STR_LEAVE_EDITOR: 'You have left the Rich Text Editor.',
4482         /**
4483         * @property STR_BEFORE_EDITOR
4484         * @description The accessibility string for the element before the iFrame
4485         * @type String
4486         */
4487         STR_BEFORE_EDITOR: 'This text field can contain stylized text and graphics. To cycle through all formatting options, use the keyboard shortcut Shift + Escape to place focus on the toolbar and navigate between options with your arrow keys. To exit this text editor use the Escape key and continue tabbing. <h4>Common formatting keyboard shortcuts:</h4><ul><li>Control Shift B sets text to bold</li> <li>Control Shift I sets text to italic</li> <li>Control Shift U underlines text</li> <li>Control Shift L adds an HTML link</li></ul>',
4488         /**
4489         * @property STR_TITLE
4490         * @description The Title of the HTML document that is created in the iFrame
4491         * @type String
4492         */
4493         STR_TITLE: 'Rich Text Area.',
4494         /**
4495         * @property STR_IMAGE_HERE
4496         * @description The text to place in the URL textbox when using the blankimage.
4497         * @type String
4498         */
4499         STR_IMAGE_HERE: 'Image URL Here',
4500         /**
4501         * @property STR_IMAGE_URL
4502         * @description The label string for Image URL
4503         * @type String
4504         */
4505         STR_IMAGE_URL: 'Image URL',
4506         /**
4507         * @property STR_LINK_URL
4508         * @description The label string for the Link URL.
4509         * @type String
4510         */
4511         STR_LINK_URL: 'Link URL',
4512         /**
4513         * @protected
4514         * @property STOP_EXEC_COMMAND
4515         * @description Set to true when you want the default execCommand function to not process anything
4516         * @type Boolean
4517         */
4518         STOP_EXEC_COMMAND: false,
4519         /**
4520         * @protected
4521         * @property STOP_NODE_CHANGE
4522         * @description Set to true when you want the default nodeChange function to not process anything
4523         * @type Boolean
4524         */
4525         STOP_NODE_CHANGE: false,
4526         /**
4527         * @protected
4528         * @property CLASS_NOEDIT
4529         * @description CSS class applied to elements that are not editable.
4530         * @type String
4531         */
4532         CLASS_NOEDIT: 'yui-noedit',
4533         /**
4534         * @protected
4535         * @property CLASS_CONTAINER
4536         * @description Default CSS class to apply to the editors container element
4537         * @type String
4538         */
4539         CLASS_CONTAINER: 'yui-editor-container',
4540         /**
4541         * @protected
4542         * @property CLASS_EDITABLE
4543         * @description Default CSS class to apply to the editors iframe element
4544         * @type String
4545         */
4546         CLASS_EDITABLE: 'yui-editor-editable',
4547         /**
4548         * @protected
4549         * @property CLASS_EDITABLE_CONT
4550         * @description Default CSS class to apply to the editors iframe's parent element
4551         * @type String
4552         */
4553         CLASS_EDITABLE_CONT: 'yui-editor-editable-container',
4554         /**
4555         * @protected
4556         * @property CLASS_PREFIX
4557         * @description Default prefix for dynamically created class names
4558         * @type String
4559         */
4560         CLASS_PREFIX: 'yui-editor',
4561         /**
4562         * @property browser
4563         * @description Standard browser detection
4564         * @type Object
4565         */
4566         browser: function() {
4567             var br = YAHOO.env.ua;
4568             //Check for webkit3
4569             if (br.webkit >= 420) {
4570                 br.webkit3 = br.webkit;
4571             } else {
4572                 br.webkit3 = 0;
4573             }
4574             br.mac = false;
4575             //Check for Mac
4576             if (navigator.userAgent.indexOf('Macintosh') !== -1) {
4577                 br.mac = true;
4578             }
4579
4580             return br;
4581         }(),
4582         /**
4583         * @method init
4584         * @description The Editor class' initialization method
4585         */
4586         init: function(p_oElement, p_oAttributes) {
4587             YAHOO.log('init', 'info', 'SimpleEditor');
4588
4589             if (!this._defaultToolbar) {
4590                 this._defaultToolbar = {
4591                     collapse: true,
4592                     titlebar: 'Text Editing Tools',
4593                     draggable: false,
4594                     buttons: [
4595                         { group: 'fontstyle', label: 'Font Name and Size',
4596                             buttons: [
4597                                 { type: 'select', label: 'Arial', value: 'fontname', disabled: true,
4598                                     menu: [
4599                                         { text: 'Arial', checked: true },
4600                                         { text: 'Arial Black' },
4601                                         { text: 'Comic Sans MS' },
4602                                         { text: 'Courier New' },
4603                                         { text: 'Lucida Console' },
4604                                         { text: 'Tahoma' },
4605                                         { text: 'Times New Roman' },
4606                                         { text: 'Trebuchet MS' },
4607                                         { text: 'Verdana' }
4608                                     ]
4609                                 },
4610                                 { type: 'spin', label: '13', value: 'fontsize', range: [ 9, 75 ], disabled: true }
4611                             ]
4612                         },
4613                         { type: 'separator' },
4614                         { group: 'textstyle', label: 'Font Style',
4615                             buttons: [
4616                                 { type: 'push', label: 'Bold CTRL + SHIFT + B', value: 'bold' },
4617                                 { type: 'push', label: 'Italic CTRL + SHIFT + I', value: 'italic' },
4618                                 { type: 'push', label: 'Underline CTRL + SHIFT + U', value: 'underline' },
4619                                 { type: 'push', label: 'Strike Through', value: 'strikethrough' },
4620                                 { type: 'separator' },
4621                                 { type: 'color', label: 'Font Color', value: 'forecolor', disabled: true },
4622                                 { type: 'color', label: 'Background Color', value: 'backcolor', disabled: true }
4623
4624                             ]
4625                         },
4626                         { type: 'separator' },
4627                         { group: 'indentlist', label: 'Lists',
4628                             buttons: [
4629                                 { type: 'push', label: 'Create an Unordered List', value: 'insertunorderedlist' },
4630                                 { type: 'push', label: 'Create an Ordered List', value: 'insertorderedlist' }
4631                             ]
4632                         },
4633                         { type: 'separator' },
4634                         { group: 'insertitem', label: 'Insert Item',
4635                             buttons: [
4636                                 { type: 'push', label: 'HTML Link CTRL + SHIFT + L', value: 'createlink', disabled: true },
4637                                 { type: 'push', label: 'Insert Image', value: 'insertimage' }
4638                             ]
4639                         }
4640                     ]
4641                 };
4642             }
4643
4644             YAHOO.widget.SimpleEditor.superclass.init.call(this, p_oElement, p_oAttributes);
4645             YAHOO.widget.EditorInfo._instances[this.get('id')] = this;
4646
4647
4648             this.currentElement = [];
4649             this.on('contentReady', function() {
4650                 this.DOMReady = true;
4651                 this.fireQueue();
4652             }, this, true);
4653
4654         },
4655         /**
4656         * @method initAttributes
4657         * @description Initializes all of the configuration attributes used to create
4658         * the editor.
4659         * @param {Object} attr Object literal specifying a set of
4660         * configuration attributes used to create the editor.
4661         */
4662         initAttributes: function(attr) {
4663             YAHOO.widget.SimpleEditor.superclass.initAttributes.call(this, attr);
4664             var self = this;
4665
4666             /**
4667             * @config nodeChangeDelay
4668             * @description Do we wrap the nodeChange method in a timeout for performance, default: true.
4669             * @default true
4670             * @type Number
4671             */
4672             this.setAttributeConfig('nodeChangeDelay', {
4673                 value: ((attr.nodeChangeDelay === false) ? false : true)
4674             });
4675             /**
4676             * @config maxUndo
4677             * @description The max number of undo levels to store.
4678             * @default 30
4679             * @type Number
4680             */
4681             this.setAttributeConfig('maxUndo', {
4682                 writeOnce: true,
4683                 value: attr.maxUndo || 30
4684             });
4685
4686             /**
4687             * @config ptags
4688             * @description If true, the editor uses &lt;P&gt; tags instead of &lt;br&gt; tags. (Use Shift + Enter to get a &lt;br&gt;)
4689             * @default false
4690             * @type Boolean
4691             */
4692             this.setAttributeConfig('ptags', {
4693                 writeOnce: true,
4694                 value: attr.ptags || false
4695             });
4696             /**
4697             * @config insert
4698             * @description If true, selection is not required for: fontname, fontsize, forecolor, backcolor.
4699             * @default false
4700             * @type Boolean
4701             */
4702             this.setAttributeConfig('insert', {
4703                 writeOnce: true,
4704                 value: attr.insert || false,
4705                 method: function(insert) {
4706                     if (insert) {
4707                         var buttons = {
4708                             fontname: true,
4709                             fontsize: true,
4710                             forecolor: true,
4711                             backcolor: true
4712                         };
4713                         var tmp = this._defaultToolbar.buttons;
4714                         for (var i = 0; i < tmp.length; i++) {
4715                             if (tmp[i].buttons) {
4716                                 for (var a = 0; a < tmp[i].buttons.length; a++) {
4717                                     if (tmp[i].buttons[a].value) {
4718                                         if (buttons[tmp[i].buttons[a].value]) {
4719                                             delete tmp[i].buttons[a].disabled;
4720                                         }
4721                                     }
4722                                 }
4723                             }
4724                         }
4725                     }
4726                 }
4727             });
4728             /**
4729             * @config container
4730             * @description Used when dynamically creating the Editor from Javascript with no default textarea.
4731             * We will create one and place it in this container. If no container is passed we will append to document.body.
4732             * @default false
4733             * @type HTMLElement
4734             */
4735             this.setAttributeConfig('container', {
4736                 writeOnce: true,
4737                 value: attr.container || false
4738             });
4739             /**
4740             * @config plainText
4741             * @description Process the inital textarea data as if it was plain text. Accounting for spaces, tabs and line feeds.
4742             * @default false
4743             * @type Boolean
4744             */
4745             this.setAttributeConfig('plainText', {
4746                 writeOnce: true,
4747                 value: attr.plainText || false
4748             });
4749             /**
4750             * @private
4751             * @config iframe
4752             * @description Internal config for holding the iframe element.
4753             * @default null
4754             * @type HTMLElement
4755             */
4756             this.setAttributeConfig('iframe', {
4757                 value: null
4758             });
4759             /**
4760             * @private
4761             * @depreciated - No longer used, should use this.get('element')
4762             * @config textarea
4763             * @description Internal config for holding the textarea element (replaced with element).
4764             * @default null
4765             * @type HTMLElement
4766             */
4767             this.setAttributeConfig('textarea', {
4768                 value: null,
4769                 writeOnce: true
4770             });
4771             /**
4772             * @config nodeChangeThreshold
4773             * @description The number of seconds that need to be in between nodeChange processing
4774             * @default 3
4775             * @type Number
4776             */
4777             this.setAttributeConfig('nodeChangeThreshold', {
4778                 value: attr.nodeChangeThreshold || 3,
4779                 validator: YAHOO.lang.isNumber
4780             });
4781             /**
4782             * @config allowNoEdit
4783             * @description Should the editor check for non-edit fields. It should be noted that this technique is not perfect. If the user does the right things, they will still be able to make changes.
4784             * Such as highlighting an element below and above the content and hitting a toolbar button or a shortcut key.
4785             * @default false
4786             * @type Boolean
4787             */
4788             this.setAttributeConfig('allowNoEdit', {
4789                 value: attr.allowNoEdit || false,
4790                 validator: YAHOO.lang.isBoolean
4791             });
4792             /**
4793             * @config limitCommands
4794             * @description Should the Editor limit the allowed execCommands to the ones available in the toolbar. If true, then execCommand and keyboard shortcuts will fail if they are not defined in the toolbar.
4795             * @default false
4796             * @type Boolean
4797             */
4798             this.setAttributeConfig('limitCommands', {
4799                 value: attr.limitCommands || false,
4800                 validator: YAHOO.lang.isBoolean
4801             });
4802             /**
4803             * @config element_cont
4804             * @description Internal config for the editors container
4805             * @default false
4806             * @type HTMLElement
4807             */
4808             this.setAttributeConfig('element_cont', {
4809                 value: attr.element_cont
4810             });
4811             /**
4812             * @private
4813             * @config editor_wrapper
4814             * @description The outter wrapper for the entire editor.
4815             * @default null
4816             * @type HTMLElement
4817             */
4818             this.setAttributeConfig('editor_wrapper', {
4819                 value: attr.editor_wrapper || null,
4820                 writeOnce: true
4821             });
4822             /**
4823             * @attribute height
4824             * @description The height of the editor iframe container, not including the toolbar..
4825             * @default Best guessed size of the textarea, for best results use CSS to style the height of the textarea or pass it in as an argument
4826             * @type String
4827             */
4828             this.setAttributeConfig('height', {
4829                 value: attr.height || Dom.getStyle(self.get('element'), 'height'),
4830                 method: function(height) {
4831                     if (this._rendered) {
4832                         //We have been rendered, change the height
4833                         if (this.get('animate')) {
4834                             var anim = new YAHOO.util.Anim(this.get('iframe').get('parentNode'), {
4835                                 height: {
4836                                     to: parseInt(height, 10)
4837                                 }
4838                             }, 0.5);
4839                             anim.animate();
4840                         } else {
4841                             Dom.setStyle(this.get('iframe').get('parentNode'), 'height', height);
4842                         }
4843                     }
4844                 }
4845             });
4846             /**
4847             * @config autoHeight
4848             * @description Remove the scrollbars from the edit area and resize it to fit the content. It will not go any lower than the current config height.
4849             * @default false
4850             * @type Boolean || Number
4851             */
4852             this.setAttributeConfig('autoHeight', {
4853                 value: attr.autoHeight || false,
4854                 method: function(a) {
4855                     if (a) {
4856                         if (this.get('iframe')) {
4857                             this.get('iframe').get('element').setAttribute('scrolling', 'no');
4858                         }
4859                         this.on('afterNodeChange', this._handleAutoHeight, this, true);
4860                         this.on('editorKeyDown', this._handleAutoHeight, this, true);
4861                         this.on('editorKeyPress', this._handleAutoHeight, this, true);
4862                     } else {
4863                         if (this.get('iframe')) {
4864                             this.get('iframe').get('element').setAttribute('scrolling', 'auto');
4865                         }
4866                         this.unsubscribe('afterNodeChange', this._handleAutoHeight);
4867                         this.unsubscribe('editorKeyDown', this._handleAutoHeight);
4868                         this.unsubscribe('editorKeyPress', this._handleAutoHeight);
4869                     }
4870                 }
4871             });
4872             /**
4873             * @attribute width
4874             * @description The width of the editor container.
4875             * @default Best guessed size of the textarea, for best results use CSS to style the width of the textarea or pass it in as an argument
4876             * @type String
4877             */
4878             this.setAttributeConfig('width', {
4879                 value: attr.width || Dom.getStyle(this.get('element'), 'width'),
4880                 method: function(width) {
4881                     if (this._rendered) {
4882                         //We have been rendered, change the width
4883                         if (this.get('animate')) {
4884                             var anim = new YAHOO.util.Anim(this.get('element_cont').get('element'), {
4885                                 width: {
4886                                     to: parseInt(width, 10)
4887                                 }
4888                             }, 0.5);
4889                             anim.animate();
4890                         } else {
4891                             this.get('element_cont').setStyle('width', width);
4892                         }
4893                     }
4894                 }
4895             });
4896
4897             /**
4898             * @attribute blankimage
4899             * @description The URL for the image placeholder to put in when inserting an image.
4900             * @default The yahooapis.com address for the current release + 'assets/blankimage.png'
4901             * @type String
4902             */
4903             this.setAttributeConfig('blankimage', {
4904                 value: attr.blankimage || this._getBlankImage()
4905             });
4906             /**
4907             * @attribute css
4908             * @description The Base CSS used to format the content of the editor
4909             * @default <code><pre>html {
4910                 height: 95%;
4911             }
4912             body {
4913                 height: 100%;
4914                 padding: 7px; background-color: #fff; font:13px/1.22 arial,helvetica,clean,sans-serif;*font-size:small;*font:x-small;
4915             }
4916             a {
4917                 color: blue;
4918                 text-decoration: underline;
4919                 cursor: pointer;
4920             }
4921             .warning-localfile {
4922                 border-bottom: 1px dashed red !important;
4923             }
4924             .yui-busy {
4925                 cursor: wait !important;
4926             }
4927             img.selected { //Safari image selection
4928                 border: 2px dotted #808080;
4929             }
4930             img {
4931                 cursor: pointer !important;
4932                 border: none;
4933             }
4934             </pre></code>
4935             * @type String
4936             */
4937             this.setAttributeConfig('css', {
4938                 value: attr.css || this._defaultCSS,
4939                 writeOnce: true
4940             });
4941             /**
4942             * @attribute html
4943             * @description The default HTML to be written to the iframe document before the contents are loaded (Note that the DOCTYPE attr will be added at render item)
4944             * @default This HTML requires a few things if you are to override:
4945                 <p><code>{TITLE}, {CSS}, {HIDDEN_CSS}, {EXTRA_CSS}</code> and <code>{CONTENT}</code> need to be there, they are passed to YAHOO.lang.substitute to be replace with other strings.<p>
4946                 <p><code>onload="document.body._rteLoaded = true;"</code> : the onload statement must be there or the editor will not finish loading.</p>
4947                 <code>
4948                 <pre>
4949                 &lt;html&gt;
4950                     &lt;head&gt;
4951                         &lt;title&gt;{TITLE}&lt;/title&gt;
4952                         &lt;meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /&gt;
4953                         &lt;style&gt;
4954                         {CSS}
4955                         &lt;/style&gt;
4956                         &lt;style&gt;
4957                         {HIDDEN_CSS}
4958                         &lt;/style&gt;
4959                         &lt;style&gt;
4960                         {EXTRA_CSS}
4961                         &lt;/style&gt;
4962                     &lt;/head&gt;
4963                 &lt;body onload="document.body._rteLoaded = true;"&gt;
4964                 {CONTENT}
4965                 &lt;/body&gt;
4966                 &lt;/html&gt;
4967                 </pre>
4968                 </code>
4969             * @type String
4970             */
4971             this.setAttributeConfig('html', {
4972                 value: attr.html || '<html><head><title>{TITLE}</title><meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /><base href="' + this._baseHREF + '"><style>{CSS}</style><style>{HIDDEN_CSS}</style><style>{EXTRA_CSS}</style></head><body onload="document.body._rteLoaded = true;">{CONTENT}</body></html>',
4973                 writeOnce: true
4974             });
4975
4976             /**
4977             * @attribute extracss
4978             * @description Extra user defined css to load after the default SimpleEditor CSS
4979             * @default ''
4980             * @type String
4981             */
4982             this.setAttributeConfig('extracss', {
4983                 value: attr.extracss || '',
4984                 writeOnce: true
4985             });
4986
4987             /**
4988             * @attribute handleSubmit
4989             * @description Config handles if the editor will attach itself to the textareas parent form's submit handler.
4990             If it is set to true, the editor will attempt to attach a submit listener to the textareas parent form.
4991             Then it will trigger the editors save handler and place the new content back into the text area before the form is submitted.
4992             * @default false
4993             * @type Boolean
4994             */
4995             this.setAttributeConfig('handleSubmit', {
4996                 value: attr.handleSubmit || false,
4997                 method: function(exec) {
4998                     if (this.get('element').form) {
4999                         if (!this._formButtons) {
5000                             this._formButtons = [];
5001                         }
5002                         if (exec) {
5003                             Event.on(this.get('element').form, 'submit', this._handleFormSubmit, this, true);
5004                             var i = this.get('element').form.getElementsByTagName('input');
5005                             for (var s = 0; s < i.length; s++) {
5006                                 var type = i[s].getAttribute('type');
5007                                 if (type && (type.toLowerCase() == 'submit')) {
5008                                     Event.on(i[s], 'click', this._handleFormButtonClick, this, true);
5009                                     this._formButtons[this._formButtons.length] = i[s];
5010                                 }
5011                             }
5012                         } else {
5013                             Event.removeListener(this.get('element').form, 'submit', this._handleFormSubmit);
5014                             if (this._formButtons) {
5015                                 Event.removeListener(this._formButtons, 'click', this._handleFormButtonClick);
5016                             }
5017                         }
5018                     }
5019                 }
5020             });
5021             /**
5022             * @attribute disabled
5023             * @description This will toggle the editor's disabled state. When the editor is disabled, designMode is turned off and a mask is placed over the iframe so no interaction can take place.
5024             All Toolbar buttons are also disabled so they cannot be used.
5025             * @default false
5026             * @type Boolean
5027             */
5028
5029             this.setAttributeConfig('disabled', {
5030                 value: false,
5031                 method: function(disabled) {
5032                     if (this._rendered) {
5033                         this._disableEditor(disabled);
5034                     }
5035                 }
5036             });
5037             /**
5038             * @config saveEl
5039             * @description When save HTML is called, this element will be updated as well as the source of data.
5040             * @default element
5041             * @type HTMLElement
5042             */
5043             this.setAttributeConfig('saveEl', {
5044                 value: this.get('element')
5045             });
5046             /**
5047             * @config toolbar_cont
5048             * @description Internal config for the toolbars container
5049             * @default false
5050             * @type Boolean
5051             */
5052             this.setAttributeConfig('toolbar_cont', {
5053                 value: null,
5054                 writeOnce: true
5055             });
5056             /**
5057             * @attribute toolbar
5058             * @description The default toolbar config.
5059             * @type Object
5060             */
5061             this.setAttributeConfig('toolbar', {
5062                 value: attr.toolbar || this._defaultToolbar,
5063                 writeOnce: true,
5064                 method: function(toolbar) {
5065                     if (!toolbar.buttonType) {
5066                         toolbar.buttonType = this._defaultToolbar.buttonType;
5067                     }
5068                     this._defaultToolbar = toolbar;
5069                 }
5070             });
5071             /**
5072             * @attribute animate
5073             * @description Should the editor animate window movements
5074             * @default false unless Animation is found, then true
5075             * @type Boolean
5076             */
5077             this.setAttributeConfig('animate', {
5078                 value: ((attr.animate) ? ((YAHOO.util.Anim) ? true : false) : false),
5079                 validator: function(value) {
5080                     var ret = true;
5081                     if (!YAHOO.util.Anim) {
5082                         ret = false;
5083                     }
5084                     return ret;
5085                 }
5086             });
5087             /**
5088             * @config panel
5089             * @description A reference to the panel we are using for windows.
5090             * @default false
5091             * @type Boolean
5092             */
5093             this.setAttributeConfig('panel', {
5094                 value: null,
5095                 writeOnce: true,
5096                 validator: function(value) {
5097                     var ret = true;
5098                     if (!YAHOO.widget.Overlay) {
5099                         ret = false;
5100                     }
5101                     return ret;
5102                 }
5103             });
5104             /**
5105             * @attribute focusAtStart
5106             * @description Should we focus the window when the content is ready?
5107             * @default false
5108             * @type Boolean
5109             */
5110             this.setAttributeConfig('focusAtStart', {
5111                 value: attr.focusAtStart || false,
5112                 writeOnce: true,
5113                 method: function(fs) {
5114                     if (fs) {
5115                         this.on('editorContentLoaded', function() {
5116                             var self = this;
5117                             setTimeout(function() {
5118                                 self.focus.call(self);
5119                                 self.editorDirty = false;
5120                             }, 400);
5121                         }, this, true);
5122                     }
5123                 }
5124             });
5125             /**
5126             * @attribute dompath
5127             * @description Toggle the display of the current Dom path below the editor
5128             * @default false
5129             * @type Boolean
5130             */
5131             this.setAttributeConfig('dompath', {
5132                 value: attr.dompath || false,
5133                 method: function(dompath) {
5134                     if (dompath && !this.dompath) {
5135                         this.dompath = document.createElement('DIV');
5136                         this.dompath.id = this.get('id') + '_dompath';
5137                         Dom.addClass(this.dompath, 'dompath');
5138                         this.get('element_cont').get('firstChild').appendChild(this.dompath);
5139                         if (this.get('iframe')) {
5140                             this._writeDomPath();
5141                         }
5142                     } else if (!dompath && this.dompath) {
5143                         this.dompath.parentNode.removeChild(this.dompath);
5144                         this.dompath = null;
5145                     }
5146                 }
5147             });
5148             /**
5149             * @attribute markup
5150             * @description Should we try to adjust the markup for the following types: semantic, css, default or xhtml
5151             * @default "semantic"
5152             * @type String
5153             */
5154             this.setAttributeConfig('markup', {
5155                 value: attr.markup || 'semantic',
5156                 validator: function(markup) {
5157                     switch (markup.toLowerCase()) {
5158                         case 'semantic':
5159                         case 'css':
5160                         case 'default':
5161                         case 'xhtml':
5162                         return true;
5163                     }
5164                     return false;
5165                 }
5166             });
5167             /**
5168             * @attribute removeLineBreaks
5169             * @description Should we remove linebreaks and extra spaces on cleanup
5170             * @default false
5171             * @type Boolean
5172             */
5173             this.setAttributeConfig('removeLineBreaks', {
5174                 value: attr.removeLineBreaks || false,
5175                 validator: YAHOO.lang.isBoolean
5176             });
5177
5178             /**
5179             * @config drag
5180             * @description Set this config to make the Editor draggable, pass 'proxy' to make use YAHOO.util.DDProxy.
5181             * @type {Boolean/String}
5182             */
5183             this.setAttributeConfig('drag', {
5184                 writeOnce: true,
5185                 value: attr.drag || false
5186             });
5187
5188             /**
5189             * @config resize
5190             * @description Set this to true to make the Editor Resizable with YAHOO.util.Resize. The default config is available: myEditor._resizeConfig
5191             * Animation will be ignored while performing this resize to allow for the dynamic change in size of the toolbar.
5192             * @type Boolean
5193             */
5194             this.setAttributeConfig('resize', {
5195                 writeOnce: true,
5196                 value: attr.resize || false
5197             });
5198
5199             /**
5200             * @config filterWord
5201             * @description Attempt to filter out MS Word HTML from the Editor's output.
5202             * @type Boolean
5203             */
5204             this.setAttributeConfig('filterWord', {
5205                 value: attr.filterWord || false,
5206                 validator: YAHOO.lang.isBoolean
5207             });
5208
5209         },
5210         /**
5211         * @private
5212         * @method _getBlankImage
5213         * @description Retrieves the full url of the image to use as the blank image.
5214         * @return {String} The URL to the blank image
5215         */
5216         _getBlankImage: function() {
5217             if (!this.DOMReady) {
5218                 this._queue[this._queue.length] = ['_getBlankImage', arguments];
5219                 return '';
5220             }
5221             var img = '';
5222             if (!this._blankImageLoaded) {
5223                 if (YAHOO.widget.EditorInfo.blankImage) {
5224                     this.set('blankimage', YAHOO.widget.EditorInfo.blankImage);
5225                     this._blankImageLoaded = true;
5226                 } else {
5227                     var div = document.createElement('div');
5228                     div.style.position = 'absolute';
5229                     div.style.top = '-9999px';
5230                     div.style.left = '-9999px';
5231                     div.className = this.CLASS_PREFIX + '-blankimage';
5232                     document.body.appendChild(div);
5233                     img = YAHOO.util.Dom.getStyle(div, 'background-image');
5234                     img = img.replace('url(', '').replace(')', '').replace(/"/g, '');
5235                     //Adobe AIR Code
5236                     img = img.replace('app:/', '');
5237                     this.set('blankimage', img);
5238                     this._blankImageLoaded = true;
5239                     div.parentNode.removeChild(div);
5240                     YAHOO.widget.EditorInfo.blankImage = img;
5241                 }
5242             } else {
5243                 img = this.get('blankimage');
5244             }
5245             return img;
5246         },
5247         /**
5248         * @private
5249         * @method _handleAutoHeight
5250         * @description Handles resizing the editor's height based on the content
5251         */
5252         _handleAutoHeight: function() {
5253             var doc = this._getDoc(),
5254                 body = doc.body,
5255                 docEl = doc.documentElement;
5256
5257             var height = parseInt(Dom.getStyle(this.get('editor_wrapper'), 'height'), 10);
5258             var newHeight = body.scrollHeight;
5259             if (this.browser.webkit) {
5260                 newHeight = docEl.scrollHeight;
5261             }
5262             if (newHeight < parseInt(this.get('height'), 10)) {
5263                 newHeight = parseInt(this.get('height'), 10);
5264             }
5265             if ((height != newHeight) && (newHeight >= parseInt(this.get('height'), 10))) {
5266                 var anim = this.get('animate');
5267                 this.set('animate', false);
5268                 this.set('height', newHeight + 'px');
5269                 this.set('animate', anim);
5270                 if (this.browser.ie) {
5271                     //Internet Explorer needs this
5272                     this.get('iframe').setStyle('height', '99%');
5273                     this.get('iframe').setStyle('zoom', '1');
5274                     var self = this;
5275                     window.setTimeout(function() {
5276                         self.get('iframe').setStyle('height', '100%');
5277                     }, 1);
5278                 }
5279             }
5280         },
5281         /**
5282         * @private
5283         * @property _formButtons
5284         * @description Array of buttons that are in the Editor's parent form (for handleSubmit)
5285         * @type Array
5286         */
5287         _formButtons: null,
5288         /**
5289         * @private
5290         * @property _formButtonClicked
5291         * @description The form button that was clicked to submit the form.
5292         * @type HTMLElement
5293         */
5294         _formButtonClicked: null,
5295         /**
5296         * @private
5297         * @method _handleFormButtonClick
5298         * @description The click listener assigned to each submit button in the Editor's parent form.
5299         * @param {Event} ev The click event
5300         */
5301         _handleFormButtonClick: function(ev) {
5302             var tar = Event.getTarget(ev);
5303             this._formButtonClicked = tar;
5304         },
5305         /**
5306         * @private
5307         * @method _handleFormSubmit
5308         * @description Handles the form submission.
5309         * @param {Object} ev The Form Submit Event
5310         */
5311         _handleFormSubmit: function(ev) {
5312             this.saveHTML();
5313
5314             var form = this.get('element').form,
5315                 tar = this._formButtonClicked || false;
5316
5317             Event.removeListener(form, 'submit', this._handleFormSubmit);
5318             if (YAHOO.env.ua.ie) {
5319                 //form.fireEvent("onsubmit");
5320                 if (tar && !tar.disabled) {
5321                     tar.click();
5322                 }
5323             } else {  // Gecko, Opera, and Safari
5324                 if (tar && !tar.disabled) {
5325                     tar.click();
5326                 }
5327                 var oEvent = document.createEvent("HTMLEvents");
5328                 oEvent.initEvent("submit", true, true);
5329                 form.dispatchEvent(oEvent);
5330                 if (YAHOO.env.ua.webkit) {
5331                     if (YAHOO.lang.isFunction(form.submit)) {
5332                         form.submit();
5333                     }
5334                 }
5335             }
5336             //2.6.0
5337             //Removed this, not need since removing Safari 2.x
5338             //Event.stopEvent(ev);
5339         },
5340         /**
5341         * @private
5342         * @method _handleFontSize
5343         * @description Handles the font size button in the toolbar.
5344         * @param {Object} o Object returned from Toolbar's buttonClick Event
5345         */
5346         _handleFontSize: function(o) {
5347             var button = this.toolbar.getButtonById(o.button.id);
5348             var value = button.get('label') + 'px';
5349             this.execCommand('fontsize', value);
5350             return false;
5351         },
5352         /**
5353         * @private
5354         * @description Handles the colorpicker buttons in the toolbar.
5355         * @param {Object} o Object returned from Toolbar's buttonClick Event
5356         */
5357         _handleColorPicker: function(o) {
5358             var cmd = o.button;
5359             var value = '#' + o.color;
5360             if ((cmd == 'forecolor') || (cmd == 'backcolor')) {
5361                 this.execCommand(cmd, value);
5362             }
5363         },
5364         /**
5365         * @private
5366         * @method _handleAlign
5367         * @description Handles the alignment buttons in the toolbar.
5368         * @param {Object} o Object returned from Toolbar's buttonClick Event
5369         */
5370         _handleAlign: function(o) {
5371             var cmd = null;
5372             for (var i = 0; i < o.button.menu.length; i++) {
5373                 if (o.button.menu[i].value == o.button.value) {
5374                     cmd = o.button.menu[i].value;
5375                 }
5376             }
5377             var value = this._getSelection();
5378
5379             this.execCommand(cmd, value);
5380             return false;
5381         },
5382         /**
5383         * @private
5384         * @method _handleAfterNodeChange
5385         * @description Fires after a nodeChange happens to setup the things that where reset on the node change (button state).
5386         */
5387         _handleAfterNodeChange: function() {
5388             var path = this._getDomPath(),
5389                 elm = null,
5390                 family = null,
5391                 fontsize = null,
5392                 validFont = false,
5393                 fn_button = this.toolbar.getButtonByValue('fontname'),
5394                 fs_button = this.toolbar.getButtonByValue('fontsize'),
5395                 hd_button = this.toolbar.getButtonByValue('heading');
5396
5397             for (var i = 0; i < path.length; i++) {
5398                 elm = path[i];
5399
5400                 var tag = elm.tagName.toLowerCase();
5401
5402
5403                 if (elm.getAttribute('tag')) {
5404                     tag = elm.getAttribute('tag');
5405                 }
5406
5407                 family = elm.getAttribute('face');
5408                 if (Dom.getStyle(elm, 'font-family')) {
5409                     family = Dom.getStyle(elm, 'font-family');
5410                     //Adobe AIR Code
5411                     family = family.replace(/'/g, '');
5412                 }
5413
5414                 if (tag.substring(0, 1) == 'h') {
5415                     if (hd_button) {
5416                         for (var h = 0; h < hd_button._configs.menu.value.length; h++) {
5417                             if (hd_button._configs.menu.value[h].value.toLowerCase() == tag) {
5418                                 hd_button.set('label', hd_button._configs.menu.value[h].text);
5419                             }
5420                         }
5421                         this._updateMenuChecked('heading', tag);
5422                     }
5423                 }
5424             }
5425
5426             if (fn_button) {
5427                 for (var b = 0; b < fn_button._configs.menu.value.length; b++) {
5428                     if (family && fn_button._configs.menu.value[b].text.toLowerCase() == family.toLowerCase()) {
5429                         validFont = true;
5430                         family = fn_button._configs.menu.value[b].text; //Put the proper menu name in the button
5431                     }
5432                 }
5433                 if (!validFont) {
5434                     family = fn_button._configs.label._initialConfig.value;
5435                 }
5436                 var familyLabel = '<span class="yui-toolbar-fontname-' + this._cleanClassName(family) + '">' + family + '</span>';
5437                 if (fn_button.get('label') != familyLabel) {
5438                     fn_button.set('label', familyLabel);
5439                     this._updateMenuChecked('fontname', family);
5440                 }
5441             }
5442
5443             if (fs_button) {
5444                 fontsize = parseInt(Dom.getStyle(elm, 'fontSize'), 10);
5445                 if ((fontsize === null) || isNaN(fontsize)) {
5446                     fontsize = fs_button._configs.label._initialConfig.value;
5447                 }
5448                 fs_button.set('label', ''+fontsize);
5449             }
5450
5451             if (!this._isElement(elm, 'body') && !this._isElement(elm, 'img')) {
5452                 this.toolbar.enableButton(fn_button);
5453                 this.toolbar.enableButton(fs_button);
5454                 this.toolbar.enableButton('forecolor');
5455                 this.toolbar.enableButton('backcolor');
5456             }
5457             if (this._isElement(elm, 'img')) {
5458                 if (YAHOO.widget.Overlay) {
5459                     this.toolbar.enableButton('createlink');
5460                 }
5461             }
5462             if (this._hasParent(elm, 'blockquote')) {
5463                 this.toolbar.selectButton('indent');
5464                 this.toolbar.disableButton('indent');
5465                 this.toolbar.enableButton('outdent');
5466             }
5467             if (this._hasParent(elm, 'ol') || this._hasParent(elm, 'ul')) {
5468                 this.toolbar.disableButton('indent');
5469             }
5470             this._lastButton = null;
5471
5472         },
5473         /**
5474         * @private
5475         * @method _handleInsertImageClick
5476         * @description Opens the Image Properties Window when the insert Image button is clicked or an Image is Double Clicked.
5477         */
5478         _handleInsertImageClick: function() {
5479             if (this.get('limitCommands')) {
5480                 if (!this.toolbar.getButtonByValue('insertimage')) {
5481                     YAHOO.log('Toolbar Button for (insertimage) was not found, skipping exec.', 'info', 'SimpleEditor');
5482                     return false;
5483                 }
5484             }
5485
5486             this.toolbar.set('disabled', true); //Disable the toolbar when the prompt is showing
5487             var _handleAEC = function() {
5488                 var el = this.currentElement[0],
5489                     src = 'http://';
5490                 if (!el) {
5491                     el = this._getSelectedElement();
5492                 }
5493                 if (el) {
5494                     if (el.getAttribute('src')) {
5495                         src = el.getAttribute('src', 2);
5496                         if (src.indexOf(this.get('blankimage')) != -1) {
5497                             src = this.STR_IMAGE_HERE;
5498                         }
5499                     }
5500                 }
5501                 var str = prompt(this.STR_IMAGE_URL + ': ', src);
5502                 if ((str !== '') && (str !== null)) {
5503                     el.setAttribute('src', str);
5504                 } else if (str === '') {
5505                     el.parentNode.removeChild(el);
5506                     this.currentElement = [];
5507                     this.nodeChange();
5508                 } else if ((str === null)) {
5509                     src = el.getAttribute('src', 2);
5510                     if (src.indexOf(this.get('blankimage')) != -1) {
5511                         el.parentNode.removeChild(el);
5512                         this.currentElement = [];
5513                         this.nodeChange();
5514                     }
5515                 }
5516                 this.closeWindow();
5517                 this.toolbar.set('disabled', false);
5518                 this.unsubscribe('afterExecCommand', _handleAEC, this, true);
5519             };
5520             this.on('afterExecCommand', _handleAEC, this, true);
5521         },
5522         /**
5523         * @private
5524         * @method _handleInsertImageWindowClose
5525         * @description Handles the closing of the Image Properties Window.
5526         */
5527         _handleInsertImageWindowClose: function() {
5528             this.nodeChange();
5529         },
5530         /**
5531         * @private
5532         * @method _isLocalFile
5533         * @param {String} url THe url/string to check
5534         * @description Checks to see if a string (href or img src) is possibly a local file reference..
5535         */
5536         _isLocalFile: function(url) {
5537             if ((url) && (url !== '') && ((url.indexOf('file:/') != -1) || (url.indexOf(':\\') != -1))) {
5538                 return true;
5539             }
5540             return false;
5541         },
5542         /**
5543         * @private
5544         * @method _handleCreateLinkClick
5545         * @description Handles the opening of the Link Properties Window when the Create Link button is clicked or an href is doubleclicked.
5546         */
5547         _handleCreateLinkClick: function() {
5548             if (this.get('limitCommands')) {
5549                 if (!this.toolbar.getButtonByValue('createlink')) {
5550                     YAHOO.log('Toolbar Button for (createlink) was not found, skipping exec.', 'info', 'SimpleEditor');
5551                     return false;
5552                 }
5553             }
5554
5555             this.toolbar.set('disabled', true); //Disable the toolbar when the prompt is showing
5556
5557             var _handleAEC = function() {
5558                 var el = this.currentElement[0],
5559                     url = '';
5560
5561                 if (el) {
5562                     if (el.getAttribute('href', 2) !== null) {
5563                         url = el.getAttribute('href', 2);
5564                     }
5565                 }
5566                 var str = prompt(this.STR_LINK_URL + ': ', url);
5567                 if ((str !== '') && (str !== null)) {
5568                     var urlValue = str;
5569                     if ((urlValue.indexOf(':/'+'/') == -1) && (urlValue.substring(0,1) != '/') && (urlValue.substring(0, 6).toLowerCase() != 'mailto')) {
5570                         if ((urlValue.indexOf('@') != -1) && (urlValue.substring(0, 6).toLowerCase() != 'mailto')) {
5571                             //Found an @ sign, prefix with mailto:
5572                             urlValue = 'mailto:' + urlValue;
5573                         } else {
5574                             /* :// not found adding */
5575                             if (urlValue.substring(0, 1) != '#') {
5576                                 //urlValue = 'http:/'+'/' + urlValue;
5577                             }
5578                         }
5579                     }
5580                     el.setAttribute('href', urlValue);
5581                 } else if (str !== null) {
5582                     var _span = this._getDoc().createElement('span');
5583                     _span.innerHTML = el.innerHTML;
5584                     Dom.addClass(_span, 'yui-non');
5585                     el.parentNode.replaceChild(_span, el);
5586                 }
5587                 this.closeWindow();
5588                 this.toolbar.set('disabled', false);
5589                 this.unsubscribe('afterExecCommand', _handleAEC, this, true);
5590             };
5591             this.on('afterExecCommand', _handleAEC, this);
5592
5593         },
5594         /**
5595         * @private
5596         * @method _handleCreateLinkWindowClose
5597         * @description Handles the closing of the Link Properties Window.
5598         */
5599         _handleCreateLinkWindowClose: function() {
5600             this.nodeChange();
5601             this.currentElement = [];
5602         },
5603         /**
5604         * @method render
5605         * @description Calls the private method _render in a setTimeout to allow for other things on the page to continue to load.
5606         */
5607         render: function() {
5608             if (this._rendered) {
5609                 return false;
5610             }
5611             YAHOO.log('Render', 'info', 'SimpleEditor');
5612             if (!this.DOMReady) {
5613                 YAHOO.log('!DOMReady', 'info', 'SimpleEditor');
5614                 this._queue[this._queue.length] = ['render', arguments];
5615                 return false;
5616             }
5617             if (this.get('element')) {
5618                 if (this.get('element').tagName) {
5619                     this._textarea = true;
5620                     if (this.get('element').tagName.toLowerCase() !== 'textarea') {
5621                         this._textarea = false;
5622                     }
5623                 } else {
5624                     YAHOO.log('No Valid Element', 'error', 'SimpleEditor');
5625                     return false;
5626                 }
5627             } else {
5628                 YAHOO.log('No Element', 'error', 'SimpleEditor');
5629                 return false;
5630             }
5631             this._rendered = true;
5632             var self = this;
5633             window.setTimeout(function() {
5634                 self._render.call(self);
5635             }, 4);
5636         },
5637         /**
5638         * @private
5639         * @method _render
5640         * @description Causes the toolbar and the editor to render and replace the textarea.
5641         */
5642         _render: function() {
5643             var self = this;
5644             this.set('textarea', this.get('element'));
5645
5646             this.get('element_cont').setStyle('display', 'none');
5647             this.get('element_cont').addClass(this.CLASS_CONTAINER);
5648
5649             this.set('iframe', this._createIframe());
5650
5651             window.setTimeout(function() {
5652                 self._setInitialContent.call(self);
5653             }, 10);
5654
5655             this.get('editor_wrapper').appendChild(this.get('iframe').get('element'));
5656
5657             if (this.get('disabled')) {
5658                 this._disableEditor(true);
5659             }
5660
5661             var tbarConf = this.get('toolbar');
5662             //Create Toolbar instance
5663             if (tbarConf instanceof Toolbar) {
5664                 this.toolbar = tbarConf;
5665                 //Set the toolbar to disabled until content is loaded
5666                 this.toolbar.set('disabled', true);
5667             } else {
5668                 //Set the toolbar to disabled until content is loaded
5669                 tbarConf.disabled = true;
5670                 this.toolbar = new Toolbar(this.get('toolbar_cont'), tbarConf);
5671             }
5672
5673             YAHOO.log('fireEvent::toolbarLoaded', 'info', 'SimpleEditor');
5674             this.fireEvent('toolbarLoaded', { type: 'toolbarLoaded', target: this.toolbar });
5675
5676
5677             this.toolbar.on('toolbarCollapsed', function() {
5678                 if (this.currentWindow) {
5679                     this.moveWindow();
5680                 }
5681             }, this, true);
5682             this.toolbar.on('toolbarExpanded', function() {
5683                 if (this.currentWindow) {
5684                     this.moveWindow();
5685                 }
5686             }, this, true);
5687             this.toolbar.on('fontsizeClick', this._handleFontSize, this, true);
5688
5689             this.toolbar.on('colorPickerClicked', function(o) {
5690                 this._handleColorPicker(o);
5691                 return false; //Stop the buttonClick event
5692             }, this, true);
5693
5694             this.toolbar.on('alignClick', this._handleAlign, this, true);
5695             this.on('afterNodeChange', this._handleAfterNodeChange, this, true);
5696             this.toolbar.on('insertimageClick', this._handleInsertImageClick, this, true);
5697             this.on('windowinsertimageClose', this._handleInsertImageWindowClose, this, true);
5698             this.toolbar.on('createlinkClick', this._handleCreateLinkClick, this, true);
5699             this.on('windowcreatelinkClose', this._handleCreateLinkWindowClose, this, true);
5700
5701
5702             //Replace Textarea with editable area
5703             this.get('parentNode').replaceChild(this.get('element_cont').get('element'), this.get('element'));
5704
5705
5706             this.setStyle('visibility', 'hidden');
5707             this.setStyle('position', 'absolute');
5708             this.setStyle('top', '-9999px');
5709             this.setStyle('left', '-9999px');
5710             this.get('element_cont').appendChild(this.get('element'));
5711             this.get('element_cont').setStyle('display', 'block');
5712
5713
5714             Dom.addClass(this.get('iframe').get('parentNode'), this.CLASS_EDITABLE_CONT);
5715             this.get('iframe').addClass(this.CLASS_EDITABLE);
5716
5717             //Set height and width of editor container
5718             this.get('element_cont').setStyle('width', this.get('width'));
5719             Dom.setStyle(this.get('iframe').get('parentNode'), 'height', this.get('height'));
5720
5721             this.get('iframe').setStyle('width', '100%'); //WIDTH
5722             this.get('iframe').setStyle('height', '100%');
5723
5724             this._setupDD();
5725
5726             window.setTimeout(function() {
5727                 self._setupAfterElement.call(self);
5728             }, 0);
5729             this.fireEvent('afterRender', { type: 'afterRender', target: this });
5730         },
5731         /**
5732         * @method execCommand
5733         * @param {String} action The "execCommand" action to try to execute (Example: bold, insertimage, inserthtml)
5734         * @param {String} value (optional) The value for a given action such as action: fontname value: 'Verdana'
5735         * @description This method attempts to try and level the differences in the various browsers and their support for execCommand actions
5736         */
5737         execCommand: function(action, value) {
5738             var beforeExec = this.fireEvent('beforeExecCommand', { type: 'beforeExecCommand', target: this, args: arguments });
5739             if ((beforeExec === false) || (this.STOP_EXEC_COMMAND)) {
5740                 this.STOP_EXEC_COMMAND = false;
5741                 return false;
5742             }
5743             this._lastCommand = action;
5744             this._setMarkupType(action);
5745             if (this.browser.ie) {
5746                 this._getWindow().focus();
5747             }
5748             var exec = true;
5749
5750             if (this.get('limitCommands')) {
5751                 if (!this.toolbar.getButtonByValue(action)) {
5752                     YAHOO.log('Toolbar Button for (' + action + ') was not found, skipping exec.', 'info', 'SimpleEditor');
5753                     exec = false;
5754                 }
5755             }
5756
5757             this.editorDirty = true;
5758
5759             if ((typeof this['cmd_' + action.toLowerCase()] == 'function') && exec) {
5760                 YAHOO.log('Found execCommand override method: (cmd_' + action.toLowerCase() + ')', 'info', 'SimpleEditor');
5761                 var retValue = this['cmd_' + action.toLowerCase()](value);
5762                 exec = retValue[0];
5763                 if (retValue[1]) {
5764                     action = retValue[1];
5765                 }
5766                 if (retValue[2]) {
5767                     value = retValue[2];
5768                 }
5769             }
5770             if (exec) {
5771                 YAHOO.log('execCommand::(' + action + '), (' + value + ')', 'info', 'SimpleEditor');
5772                 try {
5773                     this._getDoc().execCommand(action, false, value);
5774                 } catch(e) {
5775                     YAHOO.log('execCommand Failed', 'error', 'SimpleEditor');
5776                 }
5777             } else {
5778                 YAHOO.log('OVERRIDE::execCommand::(' + action + '),(' + value + ') skipped', 'warn', 'SimpleEditor');
5779             }
5780             this.on('afterExecCommand', function() {
5781                 this.unsubscribeAll('afterExecCommand');
5782                 this.nodeChange();
5783             }, this, true);
5784             this.fireEvent('afterExecCommand', { type: 'afterExecCommand', target: this });
5785
5786         },
5787     /* {{{  Command Overrides */
5788
5789         /**
5790         * @method cmd_bold
5791         * @param value Value passed from the execCommand method
5792         * @description This is an execCommand override method. It is called from execCommand when the execCommand('bold') is used.
5793         */
5794         cmd_bold: function(value) {
5795             if (!this.browser.webkit) {
5796                 var el = this._getSelectedElement();
5797                 if (el && this._isElement(el, 'span') && this._hasSelection()) {
5798                     if (el.style.fontWeight == 'bold') {
5799                         el.style.fontWeight = '';
5800                         var b = this._getDoc().createElement('b'),
5801                         par = el.parentNode;
5802                         par.replaceChild(b, el);
5803                         b.appendChild(el);
5804                     }
5805                 }
5806             }
5807             return [true];
5808         },
5809         /**
5810         * @method cmd_italic
5811         * @param value Value passed from the execCommand method
5812         * @description This is an execCommand override method. It is called from execCommand when the execCommand('italic') is used.
5813         */
5814
5815         cmd_italic: function(value) {
5816             if (!this.browser.webkit) {
5817                 var el = this._getSelectedElement();
5818                 if (el && this._isElement(el, 'span') && this._hasSelection()) {
5819                     if (el.style.fontStyle == 'italic') {
5820                         el.style.fontStyle = '';
5821                         var i = this._getDoc().createElement('i'),
5822                         par = el.parentNode;
5823                         par.replaceChild(i, el);
5824                         i.appendChild(el);
5825                     }
5826                 }
5827             }
5828             return [true];
5829         },
5830
5831
5832         /**
5833         * @method cmd_underline
5834         * @param value Value passed from the execCommand method
5835         * @description This is an execCommand override method. It is called from execCommand when the execCommand('underline') is used.
5836         */
5837         cmd_underline: function(value) {
5838             if (!this.browser.webkit) {
5839                 var el = this._getSelectedElement();
5840                 if (el && this._isElement(el, 'span')) {
5841                     if (el.style.textDecoration == 'underline') {
5842                         el.style.textDecoration = 'none';
5843                     } else {
5844                         el.style.textDecoration = 'underline';
5845                     }
5846                     return [false];
5847                 }
5848             }
5849             return [true];
5850         },
5851         /**
5852         * @method cmd_backcolor
5853         * @param value Value passed from the execCommand method
5854         * @description This is an execCommand override method. It is called from execCommand when the execCommand('backcolor') is used.
5855         */
5856         cmd_backcolor: function(value) {
5857             var exec = true,
5858                 el = this._getSelectedElement(),
5859                 action = 'backcolor';
5860
5861             if (this.browser.gecko || this.browser.opera) {
5862                 this._setEditorStyle(true);
5863                 action = 'hilitecolor';
5864             }
5865
5866             if (!this._isElement(el, 'body') && !this._hasSelection()) {
5867                 el.style.backgroundColor = value;
5868                 this._selectNode(el);
5869                 exec = false;
5870             } else {
5871                 if (this.get('insert')) {
5872                     el = this._createInsertElement({ backgroundColor: value });
5873                 } else {
5874                     this._createCurrentElement('span', { backgroundColor: value, color: el.style.color, fontSize: el.style.fontSize, fontFamily: el.style.fontFamily });
5875                     this._selectNode(this.currentElement[0]);
5876                 }
5877                 exec = false;
5878             }
5879
5880             return [exec, action];
5881         },
5882         /**
5883         * @method cmd_forecolor
5884         * @param value Value passed from the execCommand method
5885         * @description This is an execCommand override method. It is called from execCommand when the execCommand('forecolor') is used.
5886         */
5887         cmd_forecolor: function(value) {
5888             var exec = true,
5889                 el = this._getSelectedElement();
5890
5891                 if (!this._isElement(el, 'body') && !this._hasSelection()) {
5892                     Dom.setStyle(el, 'color', value);
5893                     this._selectNode(el);
5894                     exec = false;
5895                 } else {
5896                     if (this.get('insert')) {
5897                         el = this._createInsertElement({ color: value });
5898                     } else {
5899                         this._createCurrentElement('span', { color: value, fontSize: el.style.fontSize, fontFamily: el.style.fontFamily, backgroundColor: el.style.backgroundColor });
5900                         this._selectNode(this.currentElement[0]);
5901                     }
5902                     exec = false;
5903                 }
5904                 return [exec];
5905         },
5906         /**
5907         * @method cmd_unlink
5908         * @param value Value passed from the execCommand method
5909         * @description This is an execCommand override method. It is called from execCommand when the execCommand('unlink') is used.
5910         */
5911         cmd_unlink: function(value) {
5912             this._swapEl(this.currentElement[0], 'span', function(el) {
5913                 el.className = 'yui-non';
5914             });
5915             return [false];
5916         },
5917         /**
5918         * @method cmd_createlink
5919         * @param value Value passed from the execCommand method
5920         * @description This is an execCommand override method. It is called from execCommand when the execCommand('createlink') is used.
5921         */
5922         cmd_createlink: function(value) {
5923             var el = this._getSelectedElement(), _a = null;
5924             if (this._hasParent(el, 'a')) {
5925                 this.currentElement[0] = this._hasParent(el, 'a');
5926             } else if (this._isElement(el, 'li')) {
5927                 _a = this._getDoc().createElement('a');
5928                 _a.innerHTML = el.innerHTML;
5929                 el.innerHTML = '';
5930                 el.appendChild(_a);
5931                 this.currentElement[0] = _a;
5932             } else if (!this._isElement(el, 'a')) {
5933                 this._createCurrentElement('a');
5934                 _a = this._swapEl(this.currentElement[0], 'a');
5935                 this.currentElement[0] = _a;
5936             } else {
5937                 this.currentElement[0] = el;
5938             }
5939             return [false];
5940         },
5941         /**
5942         * @method cmd_insertimage
5943         * @param value Value passed from the execCommand method
5944         * @description This is an execCommand override method. It is called from execCommand when the execCommand('insertimage') is used.
5945         */
5946         cmd_insertimage: function(value) {
5947             var exec = true, _img = null, action = 'insertimage',
5948                 el = this._getSelectedElement();
5949
5950             if (value === '') {
5951                 value = this.get('blankimage');
5952             }
5953
5954             /*
5955             * @knownissue Safari Cursor Position
5956             * @browser Safari 2.x
5957             * @description The issue here is that we have no way of knowing where the cursor position is
5958             * inside of the iframe, so we have to place the newly inserted data in the best place that we can.
5959             */
5960
5961             YAHOO.log('InsertImage: ' + el.tagName, 'info', 'SimpleEditor');
5962             if (this._isElement(el, 'img')) {
5963                 this.currentElement[0] = el;
5964                 exec = false;
5965             } else {
5966                 if (this._getDoc().queryCommandEnabled(action)) {
5967                     this._getDoc().execCommand('insertimage', false, value);
5968                     var imgs = this._getDoc().getElementsByTagName('img');
5969                     for (var i = 0; i < imgs.length; i++) {
5970                         if (!YAHOO.util.Dom.hasClass(imgs[i], 'yui-img')) {
5971                             YAHOO.util.Dom.addClass(imgs[i], 'yui-img');
5972                             this.currentElement[0] = imgs[i];
5973                         }
5974                     }
5975                     exec = false;
5976                 } else {
5977                     if (el == this._getDoc().body) {
5978                         _img = this._getDoc().createElement('img');
5979                         _img.setAttribute('src', value);
5980                         YAHOO.util.Dom.addClass(_img, 'yui-img');
5981                         this._getDoc().body.appendChild(_img);
5982                     } else {
5983                         this._createCurrentElement('img');
5984                         _img = this._getDoc().createElement('img');
5985                         _img.setAttribute('src', value);
5986                         YAHOO.util.Dom.addClass(_img, 'yui-img');
5987                         this.currentElement[0].parentNode.replaceChild(_img, this.currentElement[0]);
5988                     }
5989                     this.currentElement[0] = _img;
5990                     exec = false;
5991                 }
5992             }
5993             return [exec];
5994         },
5995         /**
5996         * @method cmd_inserthtml
5997         * @param value Value passed from the execCommand method
5998         * @description This is an execCommand override method. It is called from execCommand when the execCommand('inserthtml') is used.
5999         */
6000         cmd_inserthtml: function(value) {
6001             var exec = true, action = 'inserthtml', _span = null, _range = null;
6002             /*
6003             * @knownissue Safari cursor position
6004             * @browser Safari 2.x
6005             * @description The issue here is that we have no way of knowing where the cursor position is
6006             * inside of the iframe, so we have to place the newly inserted data in the best place that we can.
6007             */
6008             if (this.browser.webkit && !this._getDoc().queryCommandEnabled(action)) {
6009                 YAHOO.log('More Safari DOM tricks (inserthtml)', 'info', 'EditorSafari');
6010                 this._createCurrentElement('img');
6011                 _span = this._getDoc().createElement('span');
6012                 _span.innerHTML = value;
6013                 this.currentElement[0].parentNode.replaceChild(_span, this.currentElement[0]);
6014                 exec = false;
6015             } else if (this.browser.ie) {
6016                 _range = this._getRange();
6017                 if (_range.item) {
6018                     _range.item(0).outerHTML = value;
6019                 } else {
6020                     _range.pasteHTML(value);
6021                 }
6022                 exec = false;
6023             }
6024             return [exec];
6025         },
6026         /**
6027         * @method cmd_list
6028         * @param tag The tag of the list you want to create (eg, ul or ol)
6029         * @description This is a combined execCommand override method. It is called from the cmd_insertorderedlist and cmd_insertunorderedlist methods.
6030         */
6031         cmd_list: function(tag) {
6032             var exec = true, list = null, li = 0, el = null, str = '',
6033                 selEl = this._getSelectedElement(), action = 'insertorderedlist';
6034                 if (tag == 'ul') {
6035                     action = 'insertunorderedlist';
6036                 }
6037             /*
6038             * @knownissue Safari 2.+ doesn't support ordered and unordered lists
6039             * @browser Safari 2.x
6040             * The issue with this workaround is that when applied to a set of text
6041             * that has BR's in it, Safari may or may not pick up the individual items as
6042             * list items. This is fixed in WebKit (Safari 3)
6043             * 2.6.0: Seems there are still some issues with List Creation and Safari 3, reverting to previously working Safari 2.x code
6044             */
6045             //if ((this.browser.webkit && !this._getDoc().queryCommandEnabled(action))) {
6046             if (this.browser.webkit) {
6047                 if (this._isElement(selEl, 'li') && this._isElement(selEl.parentNode, tag)) {
6048                     YAHOO.log('We already have a list, undo it', 'info', 'SimpleEditor');
6049                     el = selEl.parentNode;
6050                     list = this._getDoc().createElement('span');
6051                     YAHOO.util.Dom.addClass(list, 'yui-non');
6052                     str = '';
6053                     var lis = el.getElementsByTagName('li');
6054                     for (li = 0; li < lis.length; li++) {
6055                         str += '<div>' + lis[li].innerHTML + '</div>';
6056                     }
6057                     list.innerHTML = str;
6058                     this.currentElement[0] = el;
6059                     this.currentElement[0].parentNode.replaceChild(list, this.currentElement[0]);
6060                 } else {
6061                     YAHOO.log('Create list item', 'info', 'SimpleEditor');
6062                     this._createCurrentElement(tag.toLowerCase());
6063                     list = this._getDoc().createElement(tag);
6064                     for (li = 0; li < this.currentElement.length; li++) {
6065                         var newli = this._getDoc().createElement('li');
6066                         newli.innerHTML = this.currentElement[li].innerHTML + '<span class="yui-non">&nbsp;</span>&nbsp;';
6067                         list.appendChild(newli);
6068                         if (li > 0) {
6069                             this.currentElement[li].parentNode.removeChild(this.currentElement[li]);
6070                         }
6071                     }
6072
6073                     var items = list.firstChild.innerHTML.split('<br>');
6074                     if (items.length > 0) {
6075                         list.innerHTML = '';
6076                         for (var i = 0; i < items.length; i++) {
6077                             var item = this._getDoc().createElement('li');
6078                             item.innerHTML = items[i];
6079                             list.appendChild(item);
6080                         }
6081                     }
6082
6083                     this.currentElement[0].parentNode.replaceChild(list, this.currentElement[0]);
6084                     this.currentElement[0] = list;
6085                     var _h = this.currentElement[0].firstChild;
6086                     _h = Dom.getElementsByClassName('yui-non', 'span', _h)[0];
6087                     this._getSelection().setBaseAndExtent(_h, 1, _h, _h.innerText.length);
6088                 }
6089                 exec = false;
6090             } else {
6091                 el = this._getSelectedElement();
6092                 YAHOO.log(el.tagName);
6093                 if (this._isElement(el, 'li') && this._isElement(el.parentNode, tag) || (this.browser.ie && this._isElement(this._getRange().parentElement, 'li')) || (this.browser.ie && this._isElement(el, 'ul')) || (this.browser.ie && this._isElement(el, 'ol'))) { //we are in a list..
6094                     YAHOO.log('We already have a list, undo it', 'info', 'SimpleEditor');
6095                     if (this.browser.ie) {
6096                         if ((this.browser.ie && this._isElement(el, 'ul')) || (this.browser.ie && this._isElement(el, 'ol'))) {
6097                             el = el.getElementsByTagName('li')[0];
6098                         }
6099                         YAHOO.log('Undo IE', 'info', 'SimpleEditor');
6100                         str = '';
6101                         var lis2 = el.parentNode.getElementsByTagName('li');
6102                         for (var j = 0; j < lis2.length; j++) {
6103                             str += lis2[j].innerHTML + '<br>';
6104                         }
6105                         var newEl = this._getDoc().createElement('span');
6106                         newEl.innerHTML = str;
6107                         el.parentNode.parentNode.replaceChild(newEl, el.parentNode);
6108                     } else {
6109                         this.nodeChange();
6110                         this._getDoc().execCommand(action, '', el.parentNode);
6111                         this.nodeChange();
6112                     }
6113                     exec = false;
6114                 }
6115                 if (this.browser.opera) {
6116                     var self = this;
6117                     window.setTimeout(function() {
6118                         var liso = self._getDoc().getElementsByTagName('li');
6119                         for (var i = 0; i < liso.length; i++) {
6120                             if (liso[i].innerHTML.toLowerCase() == '<br>') {
6121                                 liso[i].parentNode.parentNode.removeChild(liso[i].parentNode);
6122                             }
6123                         }
6124                     },30);
6125                 }
6126                 if (this.browser.ie && exec) {
6127                     var html = '';
6128                     if (this._getRange().html) {
6129                         html = '<li>' + this._getRange().html+ '</li>';
6130                     } else {
6131                         var t = this._getRange().text.split('\n');
6132                         if (t.length > 1) {
6133                             html = '';
6134                             for (var ie = 0; ie < t.length; ie++) {
6135                                 html += '<li>' + t[ie] + '</li>';
6136                             }
6137                         } else {
6138                             var txt = this._getRange().text;
6139                             if (txt === '') {
6140                                 html = '<li id="new_list_item">' + txt + '</li>';
6141                             } else {
6142                                 html = '<li>' + txt + '</li>';
6143                             }
6144                         }
6145                     }
6146                     this._getRange().pasteHTML('<' + tag + '>' + html + '</' + tag + '>');
6147                     var new_item = this._getDoc().getElementById('new_list_item');
6148                     if (new_item) {
6149                         var range = this._getDoc().body.createTextRange();
6150                         range.moveToElementText(new_item);
6151                         range.collapse(false);
6152                         range.select();
6153                         new_item.id = '';
6154                     }
6155                     exec = false;
6156                 }
6157             }
6158             return exec;
6159         },
6160         /**
6161         * @method cmd_insertorderedlist
6162         * @param value Value passed from the execCommand method
6163         * @description This is an execCommand override method. It is called from execCommand when the execCommand('insertorderedlist ') is used.
6164         */
6165         cmd_insertorderedlist: function(value) {
6166             return [this.cmd_list('ol')];
6167         },
6168         /**
6169         * @method cmd_insertunorderedlist
6170         * @param value Value passed from the execCommand method
6171         * @description This is an execCommand override method. It is called from execCommand when the execCommand('insertunorderedlist') is used.
6172         */
6173         cmd_insertunorderedlist: function(value) {
6174             return [this.cmd_list('ul')];
6175         },
6176         /**
6177         * @method cmd_fontname
6178         * @param value Value passed from the execCommand method
6179         * @description This is an execCommand override method. It is called from execCommand when the execCommand('fontname') is used.
6180         */
6181         cmd_fontname: function(value) {
6182             var exec = true,
6183                 selEl = this._getSelectedElement();
6184
6185             this.currentFont = value;
6186             if (selEl && selEl.tagName && !this._hasSelection() && !this._isElement(selEl, 'body') && !this.get('insert')) {
6187                 YAHOO.util.Dom.setStyle(selEl, 'font-family', value);
6188                 exec = false;
6189             } else if (this.get('insert') && !this._hasSelection()) {
6190                 YAHOO.log('No selection and no selected element and we are in insert mode', 'info', 'SimpleEditor');
6191                 var el = this._createInsertElement({ fontFamily: value });
6192                 exec = false;
6193             }
6194             return [exec];
6195         },
6196         /**
6197         * @method cmd_fontsize
6198         * @param value Value passed from the execCommand method
6199         * @description This is an execCommand override method. It is called from execCommand when the execCommand('fontsize') is used.
6200         */
6201         cmd_fontsize: function(value) {
6202             var el = null, go = true;
6203             el = this._getSelectedElement();
6204             if (this.browser.webkit) {
6205                 if (this.currentElement[0]) {
6206                     if (el == this.currentElement[0]) {
6207                         go = false;
6208                         YAHOO.util.Dom.setStyle(el, 'fontSize', value);
6209                         this._selectNode(el);
6210                         this.currentElement[0] = el;
6211                     }
6212                 }
6213             }
6214             if (go) {
6215                 if (!this._isElement(this._getSelectedElement(), 'body') && (!this._hasSelection())) {
6216                     el = this._getSelectedElement();
6217                     YAHOO.util.Dom.setStyle(el, 'fontSize', value);
6218                     if (this.get('insert') && this.browser.ie) {
6219                         var r = this._getRange();
6220                         r.collapse(false);
6221                         r.select();
6222                     } else {
6223                         this._selectNode(el);
6224                     }
6225                 } else if (this.currentElement && (this.currentElement.length > 0) && (!this._hasSelection()) && (!this.get('insert'))) {
6226                     YAHOO.util.Dom.setStyle(this.currentElement, 'fontSize', value);
6227                 } else {
6228                     if (this.get('insert') && !this._hasSelection()) {
6229                         el = this._createInsertElement({ fontSize: value });
6230                         this.currentElement[0] = el;
6231                         this._selectNode(this.currentElement[0]);
6232                     } else {
6233                         this._createCurrentElement('span', {'fontSize': value, fontFamily: el.style.fontFamily, color: el.style.color, backgroundColor: el.style.backgroundColor });
6234                         this._selectNode(this.currentElement[0]);
6235                     }
6236                 }
6237             }
6238             return [false];
6239         },
6240     /* }}} */
6241         /**
6242         * @private
6243         * @method _swapEl
6244         * @param {HTMLElement} el The element to swap with
6245         * @param {String} tagName The tagname of the element that you wish to create
6246         * @param {Function} callback (optional) A function to run on the element after it is created, but before it is replaced. An element reference is passed to this function.
6247         * @description This function will create a new element in the DOM and populate it with the contents of another element. Then it will assume it's place.
6248         */
6249         _swapEl: function(el, tagName, callback) {
6250             var _el = this._getDoc().createElement(tagName);
6251             if (el) {
6252                 _el.innerHTML = el.innerHTML;
6253             }
6254             if (typeof callback == 'function') {
6255                 callback.call(this, _el);
6256             }
6257             if (el) {
6258                 el.parentNode.replaceChild(_el, el);
6259             }
6260             return _el;
6261         },
6262         /**
6263         * @private
6264         * @method _createInsertElement
6265         * @description Creates a new "currentElement" then adds some text (and other things) to make it selectable and stylable. Then the user can continue typing.
6266         * @param {Object} css (optional) Object literal containing styles to apply to the new element.
6267         * @return {HTMLElement}
6268         */
6269         _createInsertElement: function(css) {
6270             this._createCurrentElement('span', css);
6271             var el = this.currentElement[0];
6272             if (this.browser.webkit) {
6273                 //Little Safari Hackery here..
6274                 el.innerHTML = '<span class="yui-non">&nbsp;</span>';
6275                 el = el.firstChild;
6276                 this._getSelection().setBaseAndExtent(el, 1, el, el.innerText.length);
6277             } else if (this.browser.ie || this.browser.opera) {
6278                 el.innerHTML = '&nbsp;';
6279             }
6280             this.focus();
6281             this._selectNode(el, true);
6282             return el;
6283         },
6284         /**
6285         * @private
6286         * @method _createCurrentElement
6287         * @param {String} tagName (optional defaults to a) The tagname of the element that you wish to create
6288         * @param {Object} tagStyle (optional) Object literal containing styles to apply to the new element.
6289         * @description This is a work around for the various browser issues with execCommand. This method will run <code>execCommand('fontname', false, 'yui-tmp')</code> on the given selection.
6290         * It will then search the document for an element with the font-family set to <strong>yui-tmp</strong> and replace that with another span that has other information in it, then assign the new span to the
6291         * <code>this.currentElement</code> array, so we now have element references to the elements that were just modified. At this point we can use standard DOM manipulation to change them as we see fit.
6292         */
6293         _createCurrentElement: function(tagName, tagStyle) {
6294             tagName = ((tagName) ? tagName : 'a');
6295             var tar = null,
6296                 el = [],
6297                 _doc = this._getDoc();
6298
6299             if (this.currentFont) {
6300                 if (!tagStyle) {
6301                     tagStyle = {};
6302                 }
6303                 tagStyle.fontFamily = this.currentFont;
6304                 this.currentFont = null;
6305             }
6306             this.currentElement = [];
6307
6308             var _elCreate = function(tagName, tagStyle) {
6309                 var el = null;
6310                 tagName = ((tagName) ? tagName : 'span');
6311                 tagName = tagName.toLowerCase();
6312                 switch (tagName) {
6313                     case 'h1':
6314                     case 'h2':
6315                     case 'h3':
6316                     case 'h4':
6317                     case 'h5':
6318                     case 'h6':
6319                         el = _doc.createElement(tagName);
6320                         break;
6321                     default:
6322                         el = _doc.createElement(tagName);
6323                         if (tagName === 'span') {
6324                             YAHOO.util.Dom.addClass(el, 'yui-tag-' + tagName);
6325                             YAHOO.util.Dom.addClass(el, 'yui-tag');
6326                             el.setAttribute('tag', tagName);
6327                         }
6328
6329                         for (var k in tagStyle) {
6330                             if (YAHOO.lang.hasOwnProperty(tagStyle, k)) {
6331                                 el.style[k] = tagStyle[k];
6332                             }
6333                         }
6334                         break;
6335                 }
6336                 return el;
6337             };
6338
6339             if (!this._hasSelection()) {
6340                 if (this._getDoc().queryCommandEnabled('insertimage')) {
6341                     this._getDoc().execCommand('insertimage', false, 'yui-tmp-img');
6342                     var imgs = this._getDoc().getElementsByTagName('img');
6343                     for (var j = 0; j < imgs.length; j++) {
6344                         if (imgs[j].getAttribute('src', 2) == 'yui-tmp-img') {
6345                             el = _elCreate(tagName, tagStyle);
6346                             imgs[j].parentNode.replaceChild(el, imgs[j]);
6347                             this.currentElement[this.currentElement.length] = el;
6348                         }
6349                     }
6350                 } else {
6351                     if (this.currentEvent) {
6352                         tar = YAHOO.util.Event.getTarget(this.currentEvent);
6353                     } else {
6354                         //For Safari..
6355                         tar = this._getDoc().body;
6356                     }
6357                 }
6358                 if (tar) {
6359                     /*
6360                     * @knownissue Safari Cursor Position
6361                     * @browser Safari 2.x
6362                     * @description The issue here is that we have no way of knowing where the cursor position is
6363                     * inside of the iframe, so we have to place the newly inserted data in the best place that we can.
6364                     */
6365                     el = _elCreate(tagName, tagStyle);
6366                     if (this._isElement(tar, 'body') || this._isElement(tar, 'html')) {
6367                         if (this._isElement(tar, 'html')) {
6368                             tar = this._getDoc().body;
6369                         }
6370                         tar.appendChild(el);
6371                     } else if (tar.nextSibling) {
6372                         tar.parentNode.insertBefore(el, tar.nextSibling);
6373                     } else {
6374                         tar.parentNode.appendChild(el);
6375                     }
6376                     //this.currentElement = el;
6377                     this.currentElement[this.currentElement.length] = el;
6378                     this.currentEvent = null;
6379                     if (this.browser.webkit) {
6380                         //Force Safari to focus the new element
6381                         this._getSelection().setBaseAndExtent(el, 0, el, 0);
6382                         if (this.browser.webkit3) {
6383                             this._getSelection().collapseToStart();
6384                         } else {
6385                             this._getSelection().collapse(true);
6386                         }
6387                     }
6388                 }
6389             } else {
6390                 //Force CSS Styling for this action...
6391                 this._setEditorStyle(true);
6392                 this._getDoc().execCommand('fontname', false, 'yui-tmp');
6393                 var _tmp = [], __tmp, __els = ['font', 'span', 'i', 'b', 'u'];
6394
6395                 if (!this._isElement(this._getSelectedElement(), 'body')) {
6396                     __els[__els.length] = this._getDoc().getElementsByTagName(this._getSelectedElement().tagName);
6397                     __els[__els.length] = this._getDoc().getElementsByTagName(this._getSelectedElement().parentNode.tagName);
6398                 }
6399                 for (var _els = 0; _els < __els.length; _els++) {
6400                     var _tmp1 = this._getDoc().getElementsByTagName(__els[_els]);
6401                     for (var e = 0; e < _tmp1.length; e++) {
6402                         _tmp[_tmp.length] = _tmp1[e];
6403                     }
6404                 }
6405
6406
6407                 for (var i = 0; i < _tmp.length; i++) {
6408                     if ((YAHOO.util.Dom.getStyle(_tmp[i], 'font-family') == 'yui-tmp') || (_tmp[i].face && (_tmp[i].face == 'yui-tmp'))) {
6409                         if (tagName !== 'span') {
6410                             el = _elCreate(tagName, tagStyle);
6411                         } else {
6412                             el = _elCreate(_tmp[i].tagName, tagStyle);
6413                         }
6414                         el.innerHTML = _tmp[i].innerHTML;
6415                         if (this._isElement(_tmp[i], 'ol') || (this._isElement(_tmp[i], 'ul'))) {
6416                             var fc = _tmp[i].getElementsByTagName('li')[0];
6417                             _tmp[i].style.fontFamily = 'inherit';
6418                             fc.style.fontFamily = 'inherit';
6419                             el.innerHTML = fc.innerHTML;
6420                             fc.innerHTML = '';
6421                             fc.appendChild(el);
6422                             this.currentElement[this.currentElement.length] = el;
6423                         } else if (this._isElement(_tmp[i], 'li')) {
6424                             _tmp[i].innerHTML = '';
6425                             _tmp[i].appendChild(el);
6426                             _tmp[i].style.fontFamily = 'inherit';
6427                             this.currentElement[this.currentElement.length] = el;
6428                         } else {
6429                             if (_tmp[i].parentNode) {
6430                                 _tmp[i].parentNode.replaceChild(el, _tmp[i]);
6431                                 this.currentElement[this.currentElement.length] = el;
6432                                 this.currentEvent = null;
6433                                 if (this.browser.webkit) {
6434                                     //Force Safari to focus the new element
6435                                     this._getSelection().setBaseAndExtent(el, 0, el, 0);
6436                                     if (this.browser.webkit3) {
6437                                         this._getSelection().collapseToStart();
6438                                     } else {
6439                                         this._getSelection().collapse(true);
6440                                     }
6441                                 }
6442                                 if (this.browser.ie && tagStyle && tagStyle.fontSize) {
6443                                     this._getSelection().empty();
6444                                 }
6445                                 if (this.browser.gecko) {
6446                                     this._getSelection().collapseToStart();
6447                                 }
6448                             }
6449                         }
6450                     }
6451                 }
6452                 var len = this.currentElement.length;
6453                 for (var o = 0; o < len; o++) {
6454                     if ((o + 1) != len) { //Skip the last one in the list
6455                         if (this.currentElement[o] && this.currentElement[o].nextSibling) {
6456                             if (this._isElement(this.currentElement[o], 'br')) {
6457                                 this.currentElement[this.currentElement.length] = this.currentElement[o].nextSibling;
6458                             }
6459                         }
6460                     }
6461                 }
6462             }
6463         },
6464         /**
6465         * @method saveHTML
6466         * @description Cleans the HTML with the cleanHTML method then places that string back into the textarea.
6467         * @return String
6468         */
6469         saveHTML: function() {
6470             var html = this.cleanHTML();
6471             if (this._textarea) {
6472                 this.get('element').value = html;
6473             } else {
6474                 this.get('element').innerHTML = html;
6475             }
6476             if (this.get('saveEl') !== this.get('element')) {
6477                 var out = this.get('saveEl');
6478                 if (Lang.isString(out)) {
6479                     out = Dom.get(out);
6480                 }
6481                 if (out) {
6482                     if (out.tagName.toLowerCase() === 'textarea') {
6483                         out.value = html;
6484                     } else {
6485                         out.innerHTML = html;
6486                     }
6487                 }
6488             }
6489             return html;
6490         },
6491         /**
6492         * @method setEditorHTML
6493         * @param {String} incomingHTML The html content to load into the editor
6494         * @description Loads HTML into the editors body
6495         */
6496         setEditorHTML: function(incomingHTML) {
6497             var html = this._cleanIncomingHTML(incomingHTML);
6498             this._getDoc().body.innerHTML = html;
6499             this.nodeChange();
6500         },
6501         /**
6502         * @method getEditorHTML
6503         * @description Gets the unprocessed/unfiltered HTML from the editor
6504         */
6505         getEditorHTML: function() {
6506             var b = this._getDoc().body;
6507             if (b === null) {
6508                 YAHOO.log('Body is null, returning null.', 'error', 'SimpleEditor');
6509                 return null;
6510             }
6511             return this._getDoc().body.innerHTML;
6512         },
6513         /**
6514         * @method show
6515         * @description This method needs to be called if the Editor was hidden (like in a TabView or Panel). It is used to reset the editor after being in a container that was set to display none.
6516         */
6517         show: function() {
6518             if (this.browser.gecko) {
6519                 this._setDesignMode('on');
6520                 this.focus();
6521             }
6522             if (this.browser.webkit) {
6523                 var self = this;
6524                 window.setTimeout(function() {
6525                     self._setInitialContent.call(self);
6526                 }, 10);
6527             }
6528             //Adding this will close all other Editor window's when showing this one.
6529             if (this.currentWindow) {
6530                 this.closeWindow();
6531             }
6532             //Put the iframe back in place
6533             this.get('iframe').setStyle('position', 'static');
6534             this.get('iframe').setStyle('left', '');
6535         },
6536         /**
6537         * @method hide
6538         * @description This method needs to be called if the Editor is to be hidden (like in a TabView or Panel). It should be called to clear timeouts and close open editor windows.
6539         */
6540         hide: function() {
6541             //Adding this will close all other Editor window's.
6542             if (this.currentWindow) {
6543                 this.closeWindow();
6544             }
6545             if (this._fixNodesTimer) {
6546                 clearTimeout(this._fixNodesTimer);
6547                 this._fixNodesTimer = null;
6548             }
6549             if (this._nodeChangeTimer) {
6550                 clearTimeout(this._nodeChangeTimer);
6551                 this._nodeChangeTimer = null;
6552             }
6553             this._lastNodeChange = 0;
6554             //Move the iframe off of the screen, so that in containers with visiblity hidden, IE will not cover other elements.
6555             this.get('iframe').setStyle('position', 'absolute');
6556             this.get('iframe').setStyle('left', '-9999px');
6557         },
6558         /**
6559         * @method _cleanIncomingHTML
6560         * @param {String} html The unfiltered HTML
6561         * @description Process the HTML with a few regexes to clean it up and stabilize the input
6562         * @return {String} The filtered HTML
6563         */
6564         _cleanIncomingHTML: function(html) {
6565             html = html.replace(/<strong([^>]*)>/gi, '<b$1>');
6566             html = html.replace(/<\/strong>/gi, '</b>');
6567
6568             //replace embed before em check
6569             html = html.replace(/<embed([^>]*)>/gi, '<YUI_EMBED$1>');
6570             html = html.replace(/<\/embed>/gi, '</YUI_EMBED>');
6571
6572             html = html.replace(/<em([^>]*)>/gi, '<i$1>');
6573             html = html.replace(/<\/em>/gi, '</i>');
6574             html = html.replace(/_moz_dirty=""/gi, '');
6575
6576             //Put embed tags back in..
6577             html = html.replace(/<YUI_EMBED([^>]*)>/gi, '<embed$1>');
6578             html = html.replace(/<\/YUI_EMBED>/gi, '</embed>');
6579             if (this.get('plainText')) {
6580                 YAHOO.log('Filtering as plain text', 'info', 'SimpleEditor');
6581                 html = html.replace(/\n/g, '<br>').replace(/\r/g, '<br>');
6582                 html = html.replace(/  /gi, '&nbsp;&nbsp;'); //Replace all double spaces
6583                 html = html.replace(/\t/gi, '&nbsp;&nbsp;&nbsp;&nbsp;'); //Replace all tabs
6584             }
6585             //Removing Script Tags from the Editor
6586             html = html.replace(/<script([^>]*)>/gi, '<bad>');
6587             html = html.replace(/<\/script([^>]*)>/gi, '</bad>');
6588             html = html.replace(/&lt;script([^>]*)&gt;/gi, '<bad>');
6589             html = html.replace(/&lt;\/script([^>]*)&gt;/gi, '</bad>');
6590             //Replace the line feeds
6591             html = html.replace(/\r\n/g, '<YUI_LF>').replace(/\n/g, '<YUI_LF>').replace(/\r/g, '<YUI_LF>');
6592
6593             //Remove Bad HTML elements (used to be script nodes)
6594             html = html.replace(new RegExp('<bad([^>]*)>(.*?)<\/bad>', 'gi'), '');
6595             //Replace the lines feeds
6596             html = html.replace(/<YUI_LF>/g, '\n');
6597             return html;
6598         },
6599         /**
6600         * @method cleanHTML
6601         * @param {String} html The unfiltered HTML
6602         * @description Process the HTML with a few regexes to clean it up and stabilize the output
6603         * @return {String} The filtered HTML
6604         */
6605         cleanHTML: function(html) {
6606             //Start Filtering Output
6607             //Begin RegExs..
6608             if (!html) {
6609                 html = this.getEditorHTML();
6610             }
6611             var markup = this.get('markup');
6612             //Make some backups...
6613             html = this.pre_filter_linebreaks(html, markup);
6614
6615             //Filter MS Word
6616             html = this.filter_msword(html);
6617
6618                     html = html.replace(/<img([^>]*)\/>/gi, '<YUI_IMG$1>');
6619                     html = html.replace(/<img([^>]*)>/gi, '<YUI_IMG$1>');
6620
6621                     html = html.replace(/<input([^>]*)\/>/gi, '<YUI_INPUT$1>');
6622                     html = html.replace(/<input([^>]*)>/gi, '<YUI_INPUT$1>');
6623
6624                     html = html.replace(/<ul([^>]*)>/gi, '<YUI_UL$1>');
6625                     html = html.replace(/<\/ul>/gi, '<\/YUI_UL>');
6626                     html = html.replace(/<blockquote([^>]*)>/gi, '<YUI_BQ$1>');
6627                     html = html.replace(/<\/blockquote>/gi, '<\/YUI_BQ>');
6628
6629                     html = html.replace(/<embed([^>]*)>/gi, '<YUI_EMBED$1>');
6630                     html = html.replace(/<\/embed>/gi, '<\/YUI_EMBED>');
6631
6632             //Convert b and i tags to strong and em tags
6633             if ((markup == 'semantic') || (markup == 'xhtml')) {
6634                 html = html.replace(/<i(\s+[^>]*)?>/gi, '<em$1>');
6635                 html = html.replace(/<\/i>/gi, '</em>');
6636                 html = html.replace(/<b(\s+[^>]*)?>/gi, '<strong$1>');
6637                 html = html.replace(/<\/b>/gi, '</strong>');
6638             }
6639
6640             html = html.replace(/_moz_dirty=""/gi, '');
6641
6642             //normalize strikethrough
6643             html = html.replace(/<strike/gi, '<span style="text-decoration: line-through;"');
6644             html = html.replace(/\/strike>/gi, '/span>');
6645
6646
6647             //Case Changing
6648             if (this.browser.ie) {
6649                 html = html.replace(/text-decoration/gi, 'text-decoration');
6650                 html = html.replace(/font-weight/gi, 'font-weight');
6651                 html = html.replace(/_width="([^>]*)"/gi, '');
6652                 html = html.replace(/_height="([^>]*)"/gi, '');
6653                 //Cleanup Image URL's
6654                 var url = this._baseHREF.replace(/\//gi, '\\/'),
6655                     re = new RegExp('src="' + url, 'gi');
6656                 html = html.replace(re, 'src="');
6657             }
6658                     html = html.replace(/<font/gi, '<font');
6659                     html = html.replace(/<\/font>/gi, '</font>');
6660                     html = html.replace(/<span/gi, '<span');
6661                     html = html.replace(/<\/span>/gi, '</span>');
6662             if ((markup == 'semantic') || (markup == 'xhtml') || (markup == 'css')) {
6663                 html = html.replace(new RegExp('<font([^>]*)face="([^>]*)">(.*?)<\/font>', 'gi'), '<span $1 style="font-family: $2;">$3</span>');
6664                 html = html.replace(/<u/gi, '<span style="text-decoration: underline;"');
6665                 if (this.browser.webkit) {
6666                     html = html.replace(new RegExp('<span class="Apple-style-span" style="font-weight: bold;">([^>]*)<\/span>', 'gi'), '<strong>$1</strong>');
6667                     html = html.replace(new RegExp('<span class="Apple-style-span" style="font-style: italic;">([^>]*)<\/span>', 'gi'), '<em>$1</em>');
6668                 }
6669                 html = html.replace(/\/u>/gi, '/span>');
6670                 if (markup == 'css') {
6671                     html = html.replace(/<em([^>]*)>/gi, '<i$1>');
6672                     html = html.replace(/<\/em>/gi, '</i>');
6673                     html = html.replace(/<strong([^>]*)>/gi, '<b$1>');
6674                     html = html.replace(/<\/strong>/gi, '</b>');
6675                     html = html.replace(/<b/gi, '<span style="font-weight: bold;"');
6676                     html = html.replace(/\/b>/gi, '/span>');
6677                     html = html.replace(/<i/gi, '<span style="font-style: italic;"');
6678                     html = html.replace(/\/i>/gi, '/span>');
6679                 }
6680                 html = html.replace(/  /gi, ' '); //Replace all double spaces and replace with a single
6681             } else {
6682                         html = html.replace(/<u/gi, '<u');
6683                         html = html.replace(/\/u>/gi, '/u>');
6684             }
6685                     html = html.replace(/<ol([^>]*)>/gi, '<ol$1>');
6686                     html = html.replace(/\/ol>/gi, '/ol>');
6687                     html = html.replace(/<li/gi, '<li');
6688                     html = html.replace(/\/li>/gi, '/li>');
6689             html = this.filter_safari(html);
6690
6691             html = this.filter_internals(html);
6692
6693             html = this.filter_all_rgb(html);
6694
6695             //Replace our backups with the real thing
6696             html = this.post_filter_linebreaks(html, markup);
6697
6698             if (markup == 'xhtml') {
6699                         html = html.replace(/<YUI_IMG([^>]*)>/g, '<img $1 />');
6700                         html = html.replace(/<YUI_INPUT([^>]*)>/g, '<input $1 />');
6701             } else {
6702                         html = html.replace(/<YUI_IMG([^>]*)>/g, '<img $1>');
6703                         html = html.replace(/<YUI_INPUT([^>]*)>/g, '<input $1>');
6704             }
6705                     html = html.replace(/<YUI_UL([^>]*)>/g, '<ul$1>');
6706                     html = html.replace(/<\/YUI_UL>/g, '<\/ul>');
6707
6708             html = this.filter_invalid_lists(html);
6709
6710                     html = html.replace(/<YUI_BQ([^>]*)>/g, '<blockquote$1>');
6711                     html = html.replace(/<\/YUI_BQ>/g, '<\/blockquote>');
6712
6713                     html = html.replace(/<YUI_EMBED([^>]*)>/g, '<embed$1>');
6714                     html = html.replace(/<\/YUI_EMBED>/g, '<\/embed>');
6715
6716             //This should fix &amp;s in URL's
6717             html = html.replace(/ &amp; /gi, 'YUI_AMP');
6718             html = html.replace(/&amp;/gi, '&');
6719             html = html.replace(/YUI_AMP/gi, ' &amp; ');
6720
6721             //Trim the output, removing whitespace from the beginning and end
6722             html = YAHOO.lang.trim(html);
6723
6724             if (this.get('removeLineBreaks')) {
6725                 html = html.replace(/\n/g, '').replace(/\r/g, '');
6726                 html = html.replace(/  /gi, ' '); //Replace all double spaces and replace with a single
6727             }
6728
6729             //First empty span
6730             if (html.substring(0, 6).toLowerCase() == '<span>')  {
6731                 html = html.substring(6);
6732                 //Last empty span
6733                 if (html.substring(html.length - 7, html.length).toLowerCase() == '</span>')  {
6734                     html = html.substring(0, html.length - 7);
6735                 }
6736             }
6737
6738             for (var v in this.invalidHTML) {
6739                 if (YAHOO.lang.hasOwnProperty(this.invalidHTML, v)) {
6740                     if (Lang.isObject(v) && v.keepContents) {
6741                         html = html.replace(new RegExp('<' + v + '([^>]*)>(.*?)<\/' + v + '>', 'gi'), '$1');
6742                     } else {
6743                         html = html.replace(new RegExp('<' + v + '([^>]*)>(.*?)<\/' + v + '>', 'gi'), '');
6744                     }
6745                 }
6746             }
6747
6748             this.fireEvent('cleanHTML', { type: 'cleanHTML', target: this, html: html });
6749
6750             return html;
6751         },
6752         /**
6753         * @method filter_msword
6754         * @param String html The HTML string to filter
6755         * @description Filters out msword html attributes and other junk. Activate with filterWord: true in config
6756         */
6757         filter_msword: function(html) {
6758             if (!this.get('filterWord')) {
6759                 return html;
6760             }
6761             //Remove the ms o: tags
6762             html = html.replace(/<o:p>\s*<\/o:p>/g, '');
6763             html = html.replace(/<o:p>[\s\S]*?<\/o:p>/g, '&nbsp;');
6764
6765             //Remove the ms w: tags
6766             html = html.replace( /<w:[^>]*>[\s\S]*?<\/w:[^>]*>/gi, '');
6767
6768             //Remove mso-? styles.
6769             html = html.replace( /\s*mso-[^:]+:[^;"]+;?/gi, '');
6770
6771             //Remove more bogus MS styles.
6772             html = html.replace( /\s*MARGIN: 0cm 0cm 0pt\s*;/gi, '');
6773             html = html.replace( /\s*MARGIN: 0cm 0cm 0pt\s*"/gi, "\"");
6774             html = html.replace( /\s*TEXT-INDENT: 0cm\s*;/gi, '');
6775             html = html.replace( /\s*TEXT-INDENT: 0cm\s*"/gi, "\"");
6776             html = html.replace( /\s*PAGE-BREAK-BEFORE: [^\s;]+;?"/gi, "\"");
6777             html = html.replace( /\s*FONT-VARIANT: [^\s;]+;?"/gi, "\"" );
6778             html = html.replace( /\s*tab-stops:[^;"]*;?/gi, '');
6779             html = html.replace( /\s*tab-stops:[^"]*/gi, '');
6780
6781             //Remove XML declarations
6782             html = html.replace(/<\\?\?xml[^>]*>/gi, '');
6783
6784             //Remove lang
6785             html = html.replace(/<(\w[^>]*) lang=([^ |>]*)([^>]*)/gi, "<$1$3");
6786
6787             //Remove language tags
6788             html = html.replace( /<(\w[^>]*) language=([^ |>]*)([^>]*)/gi, "<$1$3");
6789
6790             //Remove onmouseover and onmouseout events (from MS Word comments effect)
6791             html = html.replace( /<(\w[^>]*) onmouseover="([^\"]*)"([^>]*)/gi, "<$1$3");
6792             html = html.replace( /<(\w[^>]*) onmouseout="([^\"]*)"([^>]*)/gi, "<$1$3");
6793
6794             return html;
6795         },
6796         /**
6797         * @method filter_invalid_lists
6798         * @param String html The HTML string to filter
6799         * @description Filters invalid ol and ul list markup, converts this: <li></li><ol>..</ol> to this: <li></li><li><ol>..</ol></li>
6800         */
6801         filter_invalid_lists: function(html) {
6802             html = html.replace(/<\/li>\n/gi, '</li>');
6803
6804             html = html.replace(/<\/li><ol>/gi, '</li><li><ol>');
6805             html = html.replace(/<\/ol>/gi, '</ol></li>');
6806             html = html.replace(/<\/ol><\/li>\n/gi, "</ol>");
6807
6808             html = html.replace(/<\/li><ul>/gi, '</li><li><ul>');
6809             html = html.replace(/<\/ul>/gi, '</ul></li>');
6810             html = html.replace(/<\/ul><\/li>\n?/gi, "</ul>");
6811
6812             html = html.replace(/<\/li>/gi, "</li>");
6813             html = html.replace(/<\/ol>/gi, "</ol>");
6814             html = html.replace(/<ol>/gi, "<ol>");
6815             html = html.replace(/<ul>/gi, "<ul>");
6816             return html;
6817         },
6818         /**
6819         * @method filter_safari
6820         * @param String html The HTML string to filter
6821         * @description Filters strings specific to Safari
6822         * @return String
6823         */
6824         filter_safari: function(html) {
6825             if (this.browser.webkit) {
6826                 //<span class="Apple-tab-span" style="white-space:pre"> </span>
6827                 html = html.replace(/<span class="Apple-tab-span" style="white-space:pre">([^>])<\/span>/gi, '&nbsp;&nbsp;&nbsp;&nbsp;');
6828                 html = html.replace(/Apple-style-span/gi, '');
6829                 html = html.replace(/style="line-height: normal;"/gi, '');
6830                 html = html.replace(/yui-wk-div/gi, '');
6831                 html = html.replace(/yui-wk-p/gi, '');
6832
6833
6834                 //Remove bogus LI's
6835                 html = html.replace(/<li><\/li>/gi, '');
6836                 html = html.replace(/<li> <\/li>/gi, '');
6837                 html = html.replace(/<li>  <\/li>/gi, '');
6838                 //Remove bogus DIV's - updated from just removing the div's to replacing /div with a break
6839                 if (this.get('ptags')) {
6840                             html = html.replace(/<div([^>]*)>/g, '<p$1>');
6841                                     html = html.replace(/<\/div>/gi, '</p>');
6842                 } else {
6843                     html = html.replace(/<div>/gi, '<br>');
6844                                     html = html.replace(/<\/div>/gi, '');
6845                 }
6846             }
6847             return html;
6848         },
6849         /**
6850         * @method filter_internals
6851         * @param String html The HTML string to filter
6852         * @description Filters internal RTE strings and bogus attrs we don't want
6853         * @return String
6854         */
6855         filter_internals: function(html) {
6856                     html = html.replace(/\r/g, '');
6857             //Fix stuff we don't want
6858                 html = html.replace(/<\/?(body|head|html)[^>]*>/gi, '');
6859             //Fix last BR in LI
6860                     html = html.replace(/<YUI_BR><\/li>/gi, '</li>');
6861
6862                     html = html.replace(/yui-tag-span/gi, '');
6863                     html = html.replace(/yui-tag/gi, '');
6864                     html = html.replace(/yui-non/gi, '');
6865                     html = html.replace(/yui-img/gi, '');
6866                     html = html.replace(/ tag="span"/gi, '');
6867                     html = html.replace(/ class=""/gi, '');
6868                     html = html.replace(/ style=""/gi, '');
6869                     html = html.replace(/ class=" "/gi, '');
6870                     html = html.replace(/ class="  "/gi, '');
6871                     html = html.replace(/ target=""/gi, '');
6872                     html = html.replace(/ title=""/gi, '');
6873
6874             if (this.browser.ie) {
6875                         html = html.replace(/ class= /gi, '');
6876                         html = html.replace(/ class= >/gi, '');
6877             }
6878
6879             return html;
6880         },
6881         /**
6882         * @method filter_all_rgb
6883         * @param String str The HTML string to filter
6884         * @description Converts all RGB color strings found in passed string to a hex color, example: style="color: rgb(0, 255, 0)" converts to style="color: #00ff00"
6885         * @return String
6886         */
6887         filter_all_rgb: function(str) {
6888             var exp = new RegExp("rgb\\s*?\\(\\s*?([0-9]+).*?,\\s*?([0-9]+).*?,\\s*?([0-9]+).*?\\)", "gi");
6889             var arr = str.match(exp);
6890             if (Lang.isArray(arr)) {
6891                 for (var i = 0; i < arr.length; i++) {
6892                     var color = this.filter_rgb(arr[i]);
6893                     str = str.replace(arr[i].toString(), color);
6894                 }
6895             }
6896
6897             return str;
6898         },
6899         /**
6900         * @method filter_rgb
6901         * @param String css The CSS string containing rgb(#,#,#);
6902         * @description Converts an RGB color string to a hex color, example: rgb(0, 255, 0) converts to #00ff00
6903         * @return String
6904         */
6905         filter_rgb: function(css) {
6906             if (css.toLowerCase().indexOf('rgb') != -1) {
6907                 var exp = new RegExp("(.*?)rgb\\s*?\\(\\s*?([0-9]+).*?,\\s*?([0-9]+).*?,\\s*?([0-9]+).*?\\)(.*?)", "gi");
6908                 var rgb = css.replace(exp, "$1,$2,$3,$4,$5").split(',');
6909
6910                 if (rgb.length == 5) {
6911                     var r = parseInt(rgb[1], 10).toString(16);
6912                     var g = parseInt(rgb[2], 10).toString(16);
6913                     var b = parseInt(rgb[3], 10).toString(16);
6914
6915                     r = r.length == 1 ? '0' + r : r;
6916                     g = g.length == 1 ? '0' + g : g;
6917                     b = b.length == 1 ? '0' + b : b;
6918
6919                     css = "#" + r + g + b;
6920                 }
6921             }
6922             return css;
6923         },
6924         /**
6925         * @method pre_filter_linebreaks
6926         * @param String html The HTML to filter
6927         * @param String markup The markup type to filter to
6928         * @description HTML Pre Filter
6929         * @return String
6930         */
6931         pre_filter_linebreaks: function(html, markup) {
6932             if (this.browser.webkit) {
6933                         html = html.replace(/<br class="khtml-block-placeholder">/gi, '<YUI_BR>');
6934                         html = html.replace(/<br class="webkit-block-placeholder">/gi, '<YUI_BR>');
6935             }
6936                     html = html.replace(/<br>/gi, '<YUI_BR>');
6937                     html = html.replace(/<br (.*?)>/gi, '<YUI_BR>');
6938                     html = html.replace(/<br\/>/gi, '<YUI_BR>');
6939                     html = html.replace(/<br \/>/gi, '<YUI_BR>');
6940                     html = html.replace(/<div><YUI_BR><\/div>/gi, '<YUI_BR>');
6941                     html = html.replace(/<p>(&nbsp;|&#160;)<\/p>/g, '<YUI_BR>');
6942                     html = html.replace(/<p><br>&nbsp;<\/p>/gi, '<YUI_BR>');
6943                     html = html.replace(/<p>&nbsp;<\/p>/gi, '<YUI_BR>');
6944             //Fix last BR
6945                 html = html.replace(/<YUI_BR>$/, '');
6946             //Fix last BR in P
6947                 html = html.replace(/<YUI_BR><\/p>/g, '</p>');
6948             if (this.browser.ie) {
6949                     html = html.replace(/&nbsp;&nbsp;&nbsp;&nbsp;/g, '\t');
6950             }
6951             return html;
6952         },
6953         /**
6954         * @method post_filter_linebreaks
6955         * @param String html The HTML to filter
6956         * @param String markup The markup type to filter to
6957         * @description HTML Pre Filter
6958         * @return String
6959         */
6960         post_filter_linebreaks: function(html, markup) {
6961             if (markup == 'xhtml') {
6962                         html = html.replace(/<YUI_BR>/g, '<br />');
6963             } else {
6964                         html = html.replace(/<YUI_BR>/g, '<br>');
6965             }
6966             return html;
6967         },
6968         /**
6969         * @method clearEditorDoc
6970         * @description Clear the doc of the Editor
6971         */
6972         clearEditorDoc: function() {
6973             this._getDoc().body.innerHTML = '&nbsp;';
6974         },
6975         /**
6976         * @method openWindow
6977         * @description Override Method for Advanced Editor
6978         */
6979         openWindow: function(win) {
6980         },
6981         /**
6982         * @method moveWindow
6983         * @description Override Method for Advanced Editor
6984         */
6985         moveWindow: function() {
6986         },
6987         /**
6988         * @private
6989         * @method _closeWindow
6990         * @description Override Method for Advanced Editor
6991         */
6992         _closeWindow: function() {
6993         },
6994         /**
6995         * @method closeWindow
6996         * @description Override Method for Advanced Editor
6997         */
6998         closeWindow: function() {
6999             //this.unsubscribeAll('afterExecCommand');
7000             this.toolbar.resetAllButtons();
7001             this.focus();
7002         },
7003         /**
7004         * @method destroy
7005         * @description Destroys the editor, all of it's elements and objects.
7006         * @return {Boolean}
7007         */
7008         destroy: function() {
7009             YAHOO.log('Destroying Editor', 'warn', 'SimpleEditor');
7010             if (this.resize) {
7011                 YAHOO.log('Destroying Resize', 'warn', 'SimpleEditor');
7012                 this.resize.destroy();
7013             }
7014             if (this.dd) {
7015                 YAHOO.log('Unreg DragDrop Instance', 'warn', 'SimpleEditor');
7016                 this.dd.unreg();
7017             }
7018             if (this.get('panel')) {
7019                 YAHOO.log('Destroying Editor Panel', 'warn', 'SimpleEditor');
7020                 this.get('panel').destroy();
7021             }
7022             this.saveHTML();
7023             this.toolbar.destroy();
7024             YAHOO.log('Restoring TextArea', 'info', 'SimpleEditor');
7025             this.setStyle('visibility', 'visible');
7026             this.setStyle('position', 'static');
7027             this.setStyle('top', '');
7028             this.setStyle('left', '');
7029             var textArea = this.get('element');
7030             this.get('element_cont').get('parentNode').replaceChild(textArea, this.get('element_cont').get('element'));
7031             this.get('element_cont').get('element').innerHTML = '';
7032             this.set('handleSubmit', false); //Remove the submit handler
7033             return true;
7034         },
7035         /**
7036         * @method toString
7037         * @description Returns a string representing the editor.
7038         * @return {String}
7039         */
7040         toString: function() {
7041             var str = 'SimpleEditor';
7042             if (this.get && this.get('element_cont')) {
7043                 str = 'SimpleEditor (#' + this.get('element_cont').get('id') + ')' + ((this.get('disabled') ? ' Disabled' : ''));
7044             }
7045             return str;
7046         }
7047     });
7048
7049 /**
7050 * @event toolbarLoaded
7051 * @description Event is fired during the render process directly after the Toolbar is loaded. Allowing you to attach events to the toolbar. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
7052 * @type YAHOO.util.CustomEvent
7053 */
7054 /**
7055 * @event cleanHTML
7056 * @description Event is fired after the cleanHTML method is called.
7057 * @type YAHOO.util.CustomEvent
7058 */
7059 /**
7060 * @event afterRender
7061 * @description Event is fired after the render process finishes. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
7062 * @type YAHOO.util.CustomEvent
7063 */
7064 /**
7065 * @event editorContentLoaded
7066 * @description Event is fired after the editor iframe's document fully loads and fires it's onload event. From here you can start injecting your own things into the document. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
7067 * @type YAHOO.util.CustomEvent
7068 */
7069 /**
7070 * @event beforeNodeChange
7071 * @description Event fires at the beginning of the nodeChange process. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
7072 * @type YAHOO.util.CustomEvent
7073 */
7074 /**
7075 * @event afterNodeChange
7076 * @description Event fires at the end of the nodeChange process. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
7077 * @type YAHOO.util.CustomEvent
7078 */
7079 /**
7080 * @event beforeExecCommand
7081 * @description Event fires at the beginning of the execCommand process. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
7082 * @type YAHOO.util.CustomEvent
7083 */
7084 /**
7085 * @event afterExecCommand
7086 * @description Event fires at the end of the execCommand process. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
7087 * @type YAHOO.util.CustomEvent
7088 */
7089 /**
7090 * @event editorMouseUp
7091 * @param {Event} ev The DOM Event that occured
7092 * @description Passed through HTML Event. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
7093 * @type YAHOO.util.CustomEvent
7094 */
7095 /**
7096 * @event editorMouseDown
7097 * @param {Event} ev The DOM Event that occured
7098 * @description Passed through HTML Event. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
7099 * @type YAHOO.util.CustomEvent
7100 */
7101 /**
7102 * @event editorDoubleClick
7103 * @param {Event} ev The DOM Event that occured
7104 * @description Passed through HTML Event. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
7105 * @type YAHOO.util.CustomEvent
7106 */
7107 /**
7108 * @event editorClick
7109 * @param {Event} ev The DOM Event that occured
7110 * @description Passed through HTML Event. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
7111 * @type YAHOO.util.CustomEvent
7112 */
7113 /**
7114 * @event editorKeyUp
7115 * @param {Event} ev The DOM Event that occured
7116 * @description Passed through HTML Event. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
7117 * @type YAHOO.util.CustomEvent
7118 */
7119 /**
7120 * @event editorKeyPress
7121 * @param {Event} ev The DOM Event that occured
7122 * @description Passed through HTML Event. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
7123 * @type YAHOO.util.CustomEvent
7124 */
7125 /**
7126 * @event editorKeyDown
7127 * @param {Event} ev The DOM Event that occured
7128 * @description Passed through HTML Event. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
7129 * @type YAHOO.util.CustomEvent
7130 */
7131 /**
7132 * @event beforeEditorMouseUp
7133 * @param {Event} ev The DOM Event that occured
7134 * @description Fires before editor event, returning false will stop the internal processing.
7135 * @type YAHOO.util.CustomEvent
7136 */
7137 /**
7138 * @event beforeEditorMouseDown
7139 * @param {Event} ev The DOM Event that occured
7140 * @description Fires before editor event, returning false will stop the internal processing.
7141 * @type YAHOO.util.CustomEvent
7142 */
7143 /**
7144 * @event beforeEditorDoubleClick
7145 * @param {Event} ev The DOM Event that occured
7146 * @description Fires before editor event, returning false will stop the internal processing.
7147 * @type YAHOO.util.CustomEvent
7148 */
7149 /**
7150 * @event beforeEditorClick
7151 * @param {Event} ev The DOM Event that occured
7152 * @description Fires before editor event, returning false will stop the internal processing.
7153 * @type YAHOO.util.CustomEvent
7154 */
7155 /**
7156 * @event beforeEditorKeyUp
7157 * @param {Event} ev The DOM Event that occured
7158 * @description Fires before editor event, returning false will stop the internal processing.
7159 * @type YAHOO.util.CustomEvent
7160 */
7161 /**
7162 * @event beforeEditorKeyPress
7163 * @param {Event} ev The DOM Event that occured
7164 * @description Fires before editor event, returning false will stop the internal processing.
7165 * @type YAHOO.util.CustomEvent
7166 */
7167 /**
7168 * @event beforeEditorKeyDown
7169 * @param {Event} ev The DOM Event that occured
7170 * @description Fires before editor event, returning false will stop the internal processing.
7171 * @type YAHOO.util.CustomEvent
7172 */
7173
7174 /**
7175 * @event editorWindowFocus
7176 * @description Fires when the iframe is focused. Note, this is window focus event, not an Editor focus event.
7177 * @type YAHOO.util.CustomEvent
7178 */
7179 /**
7180 * @event editorWindowBlur
7181 * @description Fires when the iframe is blurred. Note, this is window blur event, not an Editor blur event.
7182 * @type YAHOO.util.CustomEvent
7183 */
7184
7185
7186 /**
7187  * @description Singleton object used to track the open window objects and panels across the various open editors
7188  * @class EditorInfo
7189  * @static
7190 */
7191 YAHOO.widget.EditorInfo = {
7192     /**
7193     * @private
7194     * @property _instances
7195     * @description A reference to all editors on the page.
7196     * @type Object
7197     */
7198     _instances: {},
7199     /**
7200     * @private
7201     * @property blankImage
7202     * @description A reference to the blankImage url
7203     * @type String
7204     */
7205     blankImage: '',
7206     /**
7207     * @private
7208     * @property window
7209     * @description A reference to the currently open window object in any editor on the page.
7210     * @type Object <a href="YAHOO.widget.EditorWindow.html">YAHOO.widget.EditorWindow</a>
7211     */
7212     window: {},
7213     /**
7214     * @private
7215     * @property panel
7216     * @description A reference to the currently open panel in any editor on the page.
7217     * @type Object <a href="YAHOO.widget.Overlay.html">YAHOO.widget.Overlay</a>
7218     */
7219     panel: null,
7220     /**
7221     * @method getEditorById
7222     * @description Returns a reference to the Editor object associated with the given textarea
7223     * @param {String/HTMLElement} id The id or reference of the textarea to return the Editor instance of
7224     * @return Object <a href="YAHOO.widget.Editor.html">YAHOO.widget.Editor</a>
7225     */
7226     getEditorById: function(id) {
7227         if (!YAHOO.lang.isString(id)) {
7228             //Not a string, assume a node Reference
7229             id = id.id;
7230         }
7231         if (this._instances[id]) {
7232             return this._instances[id];
7233         }
7234         return false;
7235     },
7236     /**
7237     * @method toString
7238     * @description Returns a string representing the EditorInfo.
7239     * @return {String}
7240     */
7241     toString: function() {
7242         var len = 0;
7243         for (var i in this._instances) {
7244             if (Lang.hasOwnProperty(this._instances, i)) {
7245                 len++;
7246             }
7247         }
7248         return 'Editor Info (' + len + ' registered intance' + ((len > 1) ? 's' : '') + ')';
7249     }
7250 };
7251
7252
7253
7254
7255 })();
7256 /**
7257  * @module editor
7258  * @description <p>The Rich Text Editor is a UI control that replaces a standard HTML textarea; it allows for the rich formatting of text content, including common structural treatments like lists, formatting treatments like bold and italic text, and drag-and-drop inclusion and sizing of images. The Rich Text Editor's toolbar is extensible via a plugin architecture so that advanced implementations can achieve a high degree of customization.</p>
7259  * @namespace YAHOO.widget
7260  * @requires yahoo, dom, element, event, container_core, simpleeditor
7261  * @optional dragdrop, animation, menu, button, resize
7262  */
7263
7264 (function() {
7265 var Dom = YAHOO.util.Dom,
7266     Event = YAHOO.util.Event,
7267     Lang = YAHOO.lang,
7268     Toolbar = YAHOO.widget.Toolbar;
7269
7270     /**
7271      * The Rich Text Editor is a UI control that replaces a standard HTML textarea; it allows for the rich formatting of text content, including common structural treatments like lists, formatting treatments like bold and italic text, and drag-and-drop inclusion and sizing of images. The Rich Text Editor's toolbar is extensible via a plugin architecture so that advanced implementations can achieve a high degree of customization.
7272      * @constructor
7273      * @class Editor
7274      * @extends YAHOO.widget.SimpleEditor
7275      * @param {String/HTMLElement} el The textarea element to turn into an editor.
7276      * @param {Object} attrs Object liternal containing configuration parameters.
7277     */
7278
7279     YAHOO.widget.Editor = function(el, attrs) {
7280         YAHOO.log('Editor Initalizing', 'info', 'Editor');
7281         YAHOO.widget.Editor.superclass.constructor.call(this, el, attrs);
7282     };
7283
7284     YAHOO.extend(YAHOO.widget.Editor, YAHOO.widget.SimpleEditor, {
7285         /**
7286         * @private
7287         * @property _undoCache
7288         * @description An Array hash of the Undo Levels.
7289         * @type Array
7290         */
7291         _undoCache: null,
7292         /**
7293         * @private
7294         * @property _undoLevel
7295         * @description The index of the current undo state.
7296         * @type Number
7297         */
7298         _undoLevel: null,
7299         /**
7300         * @private
7301         * @method _hasUndoLevel
7302         * @description Checks to see if we have an undo level available
7303         * @return Boolean
7304         */
7305         _hasUndoLevel: function() {
7306             return ((this._undoCache.length > 1) && this._undoLevel);
7307         },
7308         /**
7309         * @private
7310         * @method _undoNodeChange
7311         * @description nodeChange listener for undo processing
7312         */
7313         _undoNodeChange: function() {
7314             var undo_button = this.toolbar.getButtonByValue('undo'),
7315                 redo_button = this.toolbar.getButtonByValue('redo');
7316             if (undo_button && redo_button) {
7317                 if (this._hasUndoLevel()) {
7318                     this.toolbar.enableButton(undo_button);
7319                 }
7320                 if (this._undoLevel < this._undoCache.length) {
7321                     this.toolbar.enableButton(redo_button);
7322                 }
7323             }
7324             this._lastCommand = null;
7325         },
7326         /**
7327         * @private
7328         * @method _checkUndo
7329         * @description Prunes the undo cache when it reaches the maxUndo config
7330         */
7331         _checkUndo: function() {
7332             var len = this._undoCache.length,
7333             tmp = [];
7334             if (len >= this.get('maxUndo')) {
7335                 //YAHOO.log('Undo cache too large (' + len + '), pruning..', 'info', 'SimpleEditor');
7336                 for (var i = (len - this.get('maxUndo')); i < len; i++) {
7337                     tmp.push(this._undoCache[i]);
7338                 }
7339                 this._undoCache = tmp;
7340             }
7341         },
7342         /**
7343         * @private
7344         * @method _putUndo
7345         * @description Puts the content of the Editor into the _undoCache.
7346         * //TODO Convert the hash to a series of TEXTAREAS to store state in.
7347         * @param {String} str The content of the Editor
7348         */
7349         _putUndo: function(str) {
7350             this._undoCache.push(str);
7351         },
7352         /**
7353         * @private
7354         * @method _getUndo
7355         * @description Get's a level from the undo cache.
7356         * @param {Number} index The index of the undo level we want to get.
7357         * @return {String}
7358         */
7359         _getUndo: function(index) {
7360             return this._undoCache[index];
7361         },
7362         /**
7363         * @private
7364         * @method _storeUndo
7365         * @description Method to call when you want to store an undo state. Currently called from nodeChange and _handleKeyUp
7366         */
7367         _storeUndo: function() {
7368             if (this._lastCommand === 'undo' || this._lastCommand === 'redo') {
7369                 return false;
7370             }
7371             if (!this._undoCache) {
7372                 this._undoCache = [];
7373             }
7374             this._checkUndo();
7375             var str = this.getEditorHTML();
7376             var last = this._undoCache[this._undoCache.length - 1];
7377             if (last) {
7378                 if (str !== last) {
7379                     //YAHOO.log('Storing Undo', 'info', 'SimpleEditor');
7380                     this._putUndo(str);
7381                 }
7382             } else {
7383                 //YAHOO.log('Storing Undo', 'info', 'SimpleEditor');
7384                 this._putUndo(str);
7385             }
7386             this._undoLevel = this._undoCache.length;
7387             this._undoNodeChange();
7388         },
7389         /**
7390         * @property STR_BEFORE_EDITOR
7391         * @description The accessibility string for the element before the iFrame
7392         * @type String
7393         */
7394         STR_BEFORE_EDITOR: 'This text field can contain stylized text and graphics. To cycle through all formatting options, use the keyboard shortcut Control + Shift + T to place focus on the toolbar and navigate between option heading names. <h4>Common formatting keyboard shortcuts:</h4><ul><li>Control Shift B sets text to bold</li> <li>Control Shift I sets text to italic</li> <li>Control Shift U underlines text</li> <li>Control Shift [ aligns text left</li> <li>Control Shift | centers text</li> <li>Control Shift ] aligns text right</li> <li>Control Shift L adds an HTML link</li> <li>To exit this text editor use the keyboard shortcut Control + Shift + ESC.</li></ul>',
7395         /**
7396         * @property STR_CLOSE_WINDOW
7397         * @description The Title of the close button in the Editor Window
7398         * @type String
7399         */
7400         STR_CLOSE_WINDOW: 'Close Window',
7401         /**
7402         * @property STR_CLOSE_WINDOW_NOTE
7403         * @description A note appearing in the Editor Window to tell the user that the Escape key will close the window
7404         * @type String
7405         */
7406         STR_CLOSE_WINDOW_NOTE: 'To close this window use the Control + Shift + W key',
7407         /**
7408         * @property STR_IMAGE_PROP_TITLE
7409         * @description The title for the Image Property Editor Window
7410         * @type String
7411         */
7412         STR_IMAGE_PROP_TITLE: 'Image Options',
7413         /**
7414         * @property STR_IMAGE_TITLE
7415         * @description The label string for Image Description
7416         * @type String
7417         */
7418         STR_IMAGE_TITLE: 'Description',
7419         /**
7420         * @property STR_IMAGE_SIZE
7421         * @description The label string for Image Size
7422         * @type String
7423         */
7424         STR_IMAGE_SIZE: 'Size',
7425         /**
7426         * @property STR_IMAGE_ORIG_SIZE
7427         * @description The label string for Original Image Size
7428         * @type String
7429         */
7430         STR_IMAGE_ORIG_SIZE: 'Original Size',
7431         /**
7432         * @property STR_IMAGE_COPY
7433         * @description The label string for the image copy and paste message for Opera and Safari
7434         * @type String
7435         */
7436         STR_IMAGE_COPY: '<span class="tip"><span class="icon icon-info"></span><strong>Note:</strong>To move this image just highlight it, cut, and paste where ever you\'d like.</span>',
7437         /**
7438         * @property STR_IMAGE_PADDING
7439         * @description The label string for the image padding.
7440         * @type String
7441         */
7442         STR_IMAGE_PADDING: 'Padding',
7443         /**
7444         * @property STR_IMAGE_BORDER
7445         * @description The label string for the image border.
7446         * @type String
7447         */
7448         STR_IMAGE_BORDER: 'Border',
7449         /**
7450         * @property STR_IMAGE_BORDER_SIZE
7451         * @description The label string for the image border size.
7452         * @type String
7453         */
7454         STR_IMAGE_BORDER_SIZE: 'Border Size',
7455         /**
7456         * @property STR_IMAGE_BORDER_TYPE
7457         * @description The label string for the image border type.
7458         * @type String
7459         */
7460         STR_IMAGE_BORDER_TYPE: 'Border Type',
7461         /**
7462         * @property STR_IMAGE_TEXTFLOW
7463         * @description The label string for the image text flow.
7464         * @type String
7465         */
7466         STR_IMAGE_TEXTFLOW: 'Text Flow',
7467         /**
7468         * @property STR_LOCAL_FILE_WARNING
7469         * @description The label string for the local file warning.
7470         * @type String
7471         */
7472         STR_LOCAL_FILE_WARNING: '<span class="tip"><span class="icon icon-warn"></span><strong>Note:</strong>This image/link points to a file on your computer and will not be accessible to others on the internet.</span>',
7473         /**
7474         * @property STR_LINK_PROP_TITLE
7475         * @description The label string for the Link Property Editor Window.
7476         * @type String
7477         */
7478         STR_LINK_PROP_TITLE: 'Link Options',
7479         /**
7480         * @property STR_LINK_PROP_REMOVE
7481         * @description The label string for the Remove link from text link inside the property editor.
7482         * @type String
7483         */
7484         STR_LINK_PROP_REMOVE: 'Remove link from text',
7485         /**
7486         * @property STR_LINK_NEW_WINDOW
7487         * @description The string for the open in a new window label.
7488         * @type String
7489         */
7490         STR_LINK_NEW_WINDOW: 'Open in a new window.',
7491         /**
7492         * @property STR_LINK_TITLE
7493         * @description The string for the link description.
7494         * @type String
7495         */
7496         STR_LINK_TITLE: 'Description',
7497         /**
7498         * @property STR_NONE
7499         * @description The string for the word none.
7500         * @type String
7501         */
7502         STR_NONE: 'none',
7503         /**
7504         * @protected
7505         * @property CLASS_LOCAL_FILE
7506         * @description CSS class applied to an element when it's found to have a local url.
7507         * @type String
7508         */
7509         CLASS_LOCAL_FILE: 'warning-localfile',
7510         /**
7511         * @protected
7512         * @property CLASS_HIDDEN
7513         * @description CSS class applied to the body when the hiddenelements button is pressed.
7514         * @type String
7515         */
7516         CLASS_HIDDEN: 'yui-hidden',
7517         /**
7518         * @method init
7519         * @description The Editor class' initialization method
7520         */
7521         init: function(p_oElement, p_oAttributes) {
7522             YAHOO.log('init', 'info', 'Editor');
7523
7524             this._windows = {};
7525             this._defaultToolbar = {
7526                 collapse: true,
7527                 titlebar: 'Text Editing Tools',
7528                 draggable: false,
7529                 buttonType: 'advanced',
7530                 buttons: [
7531                     { group: 'fontstyle', label: 'Font Name and Size',
7532                         buttons: [
7533                             { type: 'select', label: 'Arial', value: 'fontname', disabled: true,
7534                                 menu: [
7535                                     { text: 'Arial', checked: true },
7536                                     { text: 'Arial Black' },
7537                                     { text: 'Comic Sans MS' },
7538                                     { text: 'Courier New' },
7539                                     { text: 'Lucida Console' },
7540                                     { text: 'Tahoma' },
7541                                     { text: 'Times New Roman' },
7542                                     { text: 'Trebuchet MS' },
7543                                     { text: 'Verdana' }
7544                                 ]
7545                             },
7546                             { type: 'spin', label: '13', value: 'fontsize', range: [ 9, 75 ], disabled: true }
7547                         ]
7548                     },
7549                     { type: 'separator' },
7550                     { group: 'textstyle', label: 'Font Style',
7551                         buttons: [
7552                             { type: 'push', label: 'Bold CTRL + SHIFT + B', value: 'bold' },
7553                             { type: 'push', label: 'Italic CTRL + SHIFT + I', value: 'italic' },
7554                             { type: 'push', label: 'Underline CTRL + SHIFT + U', value: 'underline' },
7555                             { type: 'separator' },
7556                             { type: 'push', label: 'Subscript', value: 'subscript', disabled: true },
7557                             { type: 'push', label: 'Superscript', value: 'superscript', disabled: true }
7558                         ]
7559                     },
7560                     { type: 'separator' },
7561                     { group: 'textstyle2', label: '&nbsp;',
7562                         buttons: [
7563                             { type: 'color', label: 'Font Color', value: 'forecolor', disabled: true },
7564                             { type: 'color', label: 'Background Color', value: 'backcolor', disabled: true },
7565                             { type: 'separator' },
7566                             { type: 'push', label: 'Remove Formatting', value: 'removeformat', disabled: true },
7567                             { type: 'push', label: 'Show/Hide Hidden Elements', value: 'hiddenelements' }
7568                         ]
7569                     },
7570                     { type: 'separator' },
7571                     { group: 'undoredo', label: 'Undo/Redo',
7572                         buttons: [
7573                             { type: 'push', label: 'Undo', value: 'undo', disabled: true },
7574                             { type: 'push', label: 'Redo', value: 'redo', disabled: true }
7575
7576                         ]
7577                     },
7578                     { type: 'separator' },
7579                     { group: 'alignment', label: 'Alignment',
7580                         buttons: [
7581                             { type: 'push', label: 'Align Left CTRL + SHIFT + [', value: 'justifyleft' },
7582                             { type: 'push', label: 'Align Center CTRL + SHIFT + |', value: 'justifycenter' },
7583                             { type: 'push', label: 'Align Right CTRL + SHIFT + ]', value: 'justifyright' },
7584                             { type: 'push', label: 'Justify', value: 'justifyfull' }
7585                         ]
7586                     },
7587                     { type: 'separator' },
7588                     { group: 'parastyle', label: 'Paragraph Style',
7589                         buttons: [
7590                         { type: 'select', label: 'Normal', value: 'heading', disabled: true,
7591                             menu: [
7592                                 { text: 'Normal', value: 'none', checked: true },
7593                                 { text: 'Header 1', value: 'h1' },
7594                                 { text: 'Header 2', value: 'h2' },
7595                                 { text: 'Header 3', value: 'h3' },
7596                                 { text: 'Header 4', value: 'h4' },
7597                                 { text: 'Header 5', value: 'h5' },
7598                                 { text: 'Header 6', value: 'h6' }
7599                             ]
7600                         }
7601                         ]
7602                     },
7603                     { type: 'separator' },
7604
7605                     { group: 'indentlist2', label: 'Indenting and Lists',
7606                         buttons: [
7607                             { type: 'push', label: 'Indent', value: 'indent', disabled: true },
7608                             { type: 'push', label: 'Outdent', value: 'outdent', disabled: true },
7609                             { type: 'push', label: 'Create an Unordered List', value: 'insertunorderedlist' },
7610                             { type: 'push', label: 'Create an Ordered List', value: 'insertorderedlist' }
7611                         ]
7612                     },
7613                     { type: 'separator' },
7614                     { group: 'insertitem', label: 'Insert Item',
7615                         buttons: [
7616                             { type: 'push', label: 'HTML Link CTRL + SHIFT + L', value: 'createlink', disabled: true },
7617                             { type: 'push', label: 'Insert Image', value: 'insertimage' }
7618                         ]
7619                     }
7620                 ]
7621             };
7622
7623             this._defaultImageToolbarConfig = {
7624                 buttonType: this._defaultToolbar.buttonType,
7625                 buttons: [
7626                     { group: 'textflow', label: this.STR_IMAGE_TEXTFLOW + ':',
7627                         buttons: [
7628                             { type: 'push', label: 'Left', value: 'left' },
7629                             { type: 'push', label: 'Inline', value: 'inline' },
7630                             { type: 'push', label: 'Block', value: 'block' },
7631                             { type: 'push', label: 'Right', value: 'right' }
7632                         ]
7633                     },
7634                     { type: 'separator' },
7635                     { group: 'padding', label: this.STR_IMAGE_PADDING + ':',
7636                         buttons: [
7637                             { type: 'spin', label: '0', value: 'padding', range: [0, 50] }
7638                         ]
7639                     },
7640                     { type: 'separator' },
7641                     { group: 'border', label: this.STR_IMAGE_BORDER + ':',
7642                         buttons: [
7643                             { type: 'select', label: this.STR_IMAGE_BORDER_SIZE, value: 'bordersize',
7644                                 menu: [
7645                                     { text: 'none', value: '0', checked: true },
7646                                     { text: '1px', value: '1' },
7647                                     { text: '2px', value: '2' },
7648                                     { text: '3px', value: '3' },
7649                                     { text: '4px', value: '4' },
7650                                     { text: '5px', value: '5' }
7651                                 ]
7652                             },
7653                             { type: 'select', label: this.STR_IMAGE_BORDER_TYPE, value: 'bordertype', disabled: true,
7654                                 menu: [
7655                                     { text: 'Solid', value: 'solid', checked: true },
7656                                     { text: 'Dashed', value: 'dashed' },
7657                                     { text: 'Dotted', value: 'dotted' }
7658                                 ]
7659                             },
7660                             { type: 'color', label: 'Border Color', value: 'bordercolor', disabled: true }
7661                         ]
7662                     }
7663                 ]
7664             };
7665
7666             YAHOO.widget.Editor.superclass.init.call(this, p_oElement, p_oAttributes);
7667         },
7668         _render: function() {
7669             YAHOO.widget.Editor.superclass._render.apply(this, arguments);
7670             var self = this;
7671             //Render the panel in another thread and delay it a little..
7672             window.setTimeout(function() {
7673                 self._renderPanel.call(self);
7674             }, 800);
7675         },
7676         /**
7677         * @method initAttributes
7678         * @description Initializes all of the configuration attributes used to create
7679         * the editor.
7680         * @param {Object} attr Object literal specifying a set of
7681         * configuration attributes used to create the editor.
7682         */
7683         initAttributes: function(attr) {
7684             YAHOO.widget.Editor.superclass.initAttributes.call(this, attr);
7685
7686             /**
7687             * @attribute localFileWarning
7688             * @description Should we throw the warning if we detect a file that is local to their machine?
7689             * @default true
7690             * @type Boolean
7691             */
7692             this.setAttributeConfig('localFileWarning', {
7693                 value: attr.locaFileWarning || true
7694             });
7695
7696             /**
7697             * @attribute hiddencss
7698             * @description The CSS used to show/hide hidden elements on the page, these rules must be prefixed with the class provided in <code>this.CLASS_HIDDEN</code>
7699             * @default <code><pre>
7700             .yui-hidden font, .yui-hidden strong, .yui-hidden b, .yui-hidden em, .yui-hidden i, .yui-hidden u,
7701             .yui-hidden div, .yui-hidden p, .yui-hidden span, .yui-hidden img, .yui-hidden ul, .yui-hidden ol,
7702             .yui-hidden li, .yui-hidden table {
7703                 border: 1px dotted #ccc;
7704             }
7705             .yui-hidden .yui-non {
7706                 border: none;
7707             }
7708             .yui-hidden img {
7709                 padding: 2px;
7710             }</pre></code>
7711             * @type String
7712             */
7713             this.setAttributeConfig('hiddencss', {
7714                 value: attr.hiddencss || '.yui-hidden font, .yui-hidden strong, .yui-hidden b, .yui-hidden em, .yui-hidden i, .yui-hidden u, .yui-hidden div,.yui-hidden p,.yui-hidden span,.yui-hidden img, .yui-hidden ul, .yui-hidden ol, .yui-hidden li, .yui-hidden table { border: 1px dotted #ccc; } .yui-hidden .yui-non { border: none; } .yui-hidden img { padding: 2px; }',
7715                 writeOnce: true
7716             });
7717
7718         },
7719         /**
7720         * @private
7721         * @method _windows
7722         * @description A reference to the HTML elements used for the body of Editor Windows.
7723         */
7724         _windows: null,
7725         /**
7726         * @private
7727         * @method _defaultImageToolbar
7728         * @description A reference to the Toolbar Object inside Image Editor Window.
7729         */
7730         _defaultImageToolbar: null,
7731         /**
7732         * @private
7733         * @method _defaultImageToolbarConfig
7734         * @description Config to be used for the default Image Editor Window.
7735         */
7736         _defaultImageToolbarConfig: null,
7737         /**
7738         * @private
7739         * @method _fixNodes
7740         * @description Fix href and imgs as well as remove invalid HTML.
7741         */
7742         _fixNodes: function() {
7743             YAHOO.widget.Editor.superclass._fixNodes.call(this);
7744             var url = '';
7745
7746             var imgs = this._getDoc().getElementsByTagName('img');
7747             for (var im = 0; im < imgs.length; im++) {
7748                 if (imgs[im].getAttribute('href', 2)) {
7749                     url = imgs[im].getAttribute('src', 2);
7750                     if (this._isLocalFile(url)) {
7751                         Dom.addClass(imgs[im], this.CLASS_LOCAL_FILE);
7752                     } else {
7753                         Dom.removeClass(imgs[im], this.CLASS_LOCAL_FILE);
7754                     }
7755                 }
7756             }
7757             var fakeAs = this._getDoc().body.getElementsByTagName('a');
7758             for (var a = 0; a < fakeAs.length; a++) {
7759                 if (fakeAs[a].getAttribute('href', 2)) {
7760                     url = fakeAs[a].getAttribute('href', 2);
7761                     if (this._isLocalFile(url)) {
7762                         Dom.addClass(fakeAs[a], this.CLASS_LOCAL_FILE);
7763                     } else {
7764                         Dom.removeClass(fakeAs[a], this.CLASS_LOCAL_FILE);
7765                     }
7766                 }
7767             }
7768         },
7769         /**
7770         * @private
7771         * @property _disabled
7772         * @description The Toolbar items that should be disabled if there is no selection present in the editor.
7773         * @type Array
7774         */
7775         _disabled: [ 'createlink', 'forecolor', 'backcolor', 'fontname', 'fontsize', 'superscript', 'subscript', 'removeformat', 'heading', 'indent' ],
7776         /**
7777         * @private
7778         * @property _alwaysDisabled
7779         * @description The Toolbar items that should ALWAYS be disabled event if there is a selection present in the editor.
7780         * @type Object
7781         */
7782         _alwaysDisabled: { 'outdent': true },
7783         /**
7784         * @private
7785         * @property _alwaysEnabled
7786         * @description The Toolbar items that should ALWAYS be enabled event if there isn't a selection present in the editor.
7787         * @type Object
7788         */
7789         _alwaysEnabled: { hiddenelements: true },
7790         /**
7791         * @private
7792         * @method _handleKeyDown
7793         * @param {Event} ev The event we are working on.
7794         * @description Override method that handles some new keydown events inside the iFrame document.
7795         */
7796         _handleKeyDown: function(ev) {
7797             YAHOO.widget.Editor.superclass._handleKeyDown.call(this, ev);
7798             var doExec = false,
7799                 action = null,
7800                 exec = false;
7801
7802             switch (ev.keyCode) {
7803                 //case 219: //Left
7804                 case this._keyMap.JUSTIFY_LEFT.key: //Left
7805                     if (this._checkKey(this._keyMap.JUSTIFY_LEFT, ev)) {
7806                         action = 'justifyleft';
7807                         doExec = true;
7808                     }
7809                     break;
7810                 //case 220: //Center
7811                 case this._keyMap.JUSTIFY_CENTER.key:
7812                     if (this._checkKey(this._keyMap.JUSTIFY_CENTER, ev)) {
7813                         action = 'justifycenter';
7814                         doExec = true;
7815                     }
7816                     break;
7817                 case 221: //Right
7818                 case this._keyMap.JUSTIFY_RIGHT.key:
7819                     if (this._checkKey(this._keyMap.JUSTIFY_RIGHT, ev)) {
7820                         action = 'justifyright';
7821                         doExec = true;
7822                     }
7823                     break;
7824             }
7825             if (doExec && action) {
7826                 this.execCommand(action, null);
7827                 Event.stopEvent(ev);
7828                 this.nodeChange();
7829             }
7830         },
7831         /**
7832         * @private
7833         * @method _renderCreateLinkWindow
7834         * @description Pre renders the CreateLink window so we get faster window opening.
7835         */
7836         _renderCreateLinkWindow: function() {
7837                 var str = '<label for="' + this.get('id') + '_createlink_url"><strong>' + this.STR_LINK_URL + ':</strong> <input type="text" name="' + this.get('id') + '_createlink_url" id="' + this.get('id') + '_createlink_url" value=""></label>';
7838                 str += '<label for="' + this.get('id') + '_createlink_target"><strong>&nbsp;</strong><input type="checkbox" name="' + this.get('id') + '_createlink_target" id="' + this.get('id') + '_createlink_target" value="_blank" class="createlink_target"> ' + this.STR_LINK_NEW_WINDOW + '</label>';
7839                 str += '<label for="' + this.get('id') + '_createlink_title"><strong>' + this.STR_LINK_TITLE + ':</strong> <input type="text" name="' + this.get('id') + '_createlink_title" id="' + this.get('id') + '_createlink_title" value=""></label>';
7840
7841                 var body = document.createElement('div');
7842                 body.innerHTML = str;
7843
7844                 var unlinkCont = document.createElement('div');
7845                 unlinkCont.className = 'removeLink';
7846                 var unlink = document.createElement('a');
7847                 unlink.href = '#';
7848                 unlink.innerHTML = this.STR_LINK_PROP_REMOVE;
7849                 unlink.title = this.STR_LINK_PROP_REMOVE;
7850                 Event.on(unlink, 'click', function(ev) {
7851                     Event.stopEvent(ev);
7852                     this.unsubscribeAll('afterExecCommand');
7853                     this.execCommand('unlink');
7854                     this.closeWindow();
7855                 }, this, true);
7856                 unlinkCont.appendChild(unlink);
7857                 body.appendChild(unlinkCont);
7858
7859                 this._windows.createlink = {};
7860                 this._windows.createlink.body = body;
7861                 //body.style.display = 'none';
7862                 Event.on(body, 'keyup', function(e) {
7863                     Event.stopPropagation(e);
7864                 });
7865                 this.get('panel').editor_form.appendChild(body);
7866                 this.fireEvent('windowCreateLinkRender', { type: 'windowCreateLinkRender', panel: this.get('panel'), body: body });
7867                 return body;
7868         },
7869         _handleCreateLinkClick: function() {
7870             var el = this._getSelectedElement();
7871             if (this._isElement(el, 'img')) {
7872                 this.STOP_EXEC_COMMAND = true;
7873                 this.currentElement[0] = el;
7874                 this.toolbar.fireEvent('insertimageClick', { type: 'insertimageClick', target: this.toolbar });
7875                 this.fireEvent('afterExecCommand', { type: 'afterExecCommand', target: this });
7876                 return false;
7877             }
7878             if (this.get('limitCommands')) {
7879                 if (!this.toolbar.getButtonByValue('createlink')) {
7880                     YAHOO.log('Toolbar Button for (createlink) was not found, skipping exec.', 'info', 'Editor');
7881                     return false;
7882                 }
7883             }
7884
7885             this.on('afterExecCommand', function() {
7886                 var win = new YAHOO.widget.EditorWindow('createlink', {
7887                     width: '350px'
7888                 });
7889
7890                 var el = this.currentElement[0],
7891                     url = '',
7892                     title = '',
7893                     target = '',
7894                     localFile = false;
7895                 if (el) {
7896                     win.el = el;
7897                     if (el.getAttribute('href', 2) !== null) {
7898                         url = el.getAttribute('href', 2);
7899                         if (this._isLocalFile(url)) {
7900                             //Local File throw Warning
7901                             YAHOO.log('Local file reference found, show local warning', 'warn', 'Editor');
7902                             win.setFooter(this.STR_LOCAL_FILE_WARNING);
7903                             localFile = true;
7904                         } else {
7905                             win.setFooter(' ');
7906                         }
7907                     }
7908                     if (el.getAttribute('title') !== null) {
7909                         title = el.getAttribute('title');
7910                     }
7911                     if (el.getAttribute('target') !== null) {
7912                         target = el.getAttribute('target');
7913                     }
7914                 }
7915                 var body = null;
7916                 if (this._windows.createlink && this._windows.createlink.body) {
7917                     body = this._windows.createlink.body;
7918                 } else {
7919                     body = this._renderCreateLinkWindow();
7920                 }
7921
7922                 win.setHeader(this.STR_LINK_PROP_TITLE);
7923                 win.setBody(body);
7924
7925                 Event.purgeElement(this.get('id') + '_createlink_url');
7926
7927                 Dom.get(this.get('id') + '_createlink_url').value = url;
7928                 Dom.get(this.get('id') + '_createlink_title').value = title;
7929                 Dom.get(this.get('id') + '_createlink_target').checked = ((target) ? true : false);
7930
7931
7932                 Event.onAvailable(this.get('id') + '_createlink_url', function() {
7933                     var id = this.get('id');
7934                     window.setTimeout(function() {
7935                         try {
7936                             YAHOO.util.Dom.get(id + '_createlink_url').focus();
7937                         } catch (e) {}
7938                     }, 50);
7939
7940                     if (this._isLocalFile(url)) {
7941                         //Local File throw Warning
7942                         Dom.addClass(this.get('id') + '_createlink_url', 'warning');
7943                         YAHOO.log('Local file reference found, show local warning', 'warn', 'Editor');
7944                         this.get('panel').setFooter(this.STR_LOCAL_FILE_WARNING);
7945                     } else {
7946                         Dom.removeClass(this.get('id') + '_createlink_url', 'warning');
7947                         this.get('panel').setFooter(' ');
7948                     }
7949                     Event.on(this.get('id') + '_createlink_url', 'blur', function() {
7950                         var url = Dom.get(this.get('id') + '_createlink_url');
7951                         if (this._isLocalFile(url.value)) {
7952                             //Local File throw Warning
7953                             Dom.addClass(url, 'warning');
7954                             YAHOO.log('Local file reference found, show local warning', 'warn', 'Editor');
7955                             this.get('panel').setFooter(this.STR_LOCAL_FILE_WARNING);
7956                         } else {
7957                             Dom.removeClass(url, 'warning');
7958                             this.get('panel').setFooter(' ');
7959                         }
7960                     }, this, true);
7961                 }, this, true);
7962
7963                 this.openWindow(win);
7964
7965             });
7966         },
7967         /**
7968         * @private
7969         * @method _handleCreateLinkWindowClose
7970         * @description Handles the closing of the Link Properties Window.
7971         */
7972         _handleCreateLinkWindowClose: function() {
7973
7974             var url = Dom.get(this.get('id') + '_createlink_url'),
7975                 target = Dom.get(this.get('id') + '_createlink_target'),
7976                 title = Dom.get(this.get('id') + '_createlink_title'),
7977                 el = arguments[0].win.el,
7978                 a = el;
7979
7980             if (url && url.value) {
7981                 var urlValue = url.value;
7982                 if ((urlValue.indexOf(':/'+'/') == -1) && (urlValue.substring(0,1) != '/') && (urlValue.substring(0, 6).toLowerCase() != 'mailto')) {
7983                     if ((urlValue.indexOf('@') != -1) && (urlValue.substring(0, 6).toLowerCase() != 'mailto')) {
7984                         //Found an @ sign, prefix with mailto:
7985                         urlValue = 'mailto:' + urlValue;
7986                     } else {
7987                         // :// not found adding
7988                         if (urlValue.substring(0, 1) != '#') {
7989                             urlValue = 'http:/'+'/' + urlValue;
7990                         }
7991
7992                     }
7993                 }
7994                 el.setAttribute('href', urlValue);
7995                 if (target.checked) {
7996                     el.setAttribute('target', target.value);
7997                 } else {
7998                     el.setAttribute('target', '');
7999                 }
8000                 el.setAttribute('title', ((title.value) ? title.value : ''));
8001
8002             } else {
8003                 var _span = this._getDoc().createElement('span');
8004                 _span.innerHTML = el.innerHTML;
8005                 Dom.addClass(_span, 'yui-non');
8006                 el.parentNode.replaceChild(_span, el);
8007             }
8008             Dom.removeClass(url, 'warning');
8009             Dom.get(this.get('id') + '_createlink_url').value = '';
8010             Dom.get(this.get('id') + '_createlink_title').value = '';
8011             Dom.get(this.get('id') + '_createlink_target').checked = false;
8012             this.nodeChange();
8013             this.currentElement = [];
8014
8015         },
8016         /**
8017         * @private
8018         * @method _renderInsertImageWindow
8019         * @description Pre renders the InsertImage window so we get faster window opening.
8020         */
8021         _renderInsertImageWindow: function() {
8022                 var el = this.currentElement[0];
8023                 var str = '<label for="' + this.get('id') + '_insertimage_url"><strong>' + this.STR_IMAGE_URL + ':</strong> <input type="text" id="' + this.get('id') + '_insertimage_url" value="" size="40"></label>';
8024                 var body = document.createElement('div');
8025                 body.innerHTML = str;
8026
8027                 var tbarCont = document.createElement('div');
8028                 tbarCont.id = this.get('id') + '_img_toolbar';
8029                 body.appendChild(tbarCont);
8030
8031                 var str2 = '<label for="' + this.get('id') + '_insertimage_title"><strong>' + this.STR_IMAGE_TITLE + ':</strong> <input type="text" id="' + this.get('id') + '_insertimage_title" value="" size="40"></label>';
8032                 str2 += '<label for="' + this.get('id') + '_insertimage_link"><strong>' + this.STR_LINK_URL + ':</strong> <input type="text" name="' + this.get('id') + '_insertimage_link" id="' + this.get('id') + '_insertimage_link" value=""></label>';
8033                 str2 += '<label for="' + this.get('id') + '_insertimage_target"><strong>&nbsp;</strong><input type="checkbox" name="' + this.get('id') + '_insertimage_target_" id="' + this.get('id') + '_insertimage_target" value="_blank" class="insertimage_target"> ' + this.STR_LINK_NEW_WINDOW + '</label>';
8034                 var div = document.createElement('div');
8035                 div.innerHTML = str2;
8036                 body.appendChild(div);
8037
8038                 var o = {};
8039                 Lang.augmentObject(o, this._defaultImageToolbarConfig); //Break the config reference
8040
8041                 var tbar = new YAHOO.widget.Toolbar(tbarCont, o);
8042                 tbar.editor_el = el;
8043                 this._defaultImageToolbar = tbar;
8044
8045                 var cont = tbar.get('cont');
8046                 var hw = document.createElement('div');
8047                 hw.className = 'yui-toolbar-group yui-toolbar-group-height-width height-width';
8048                 hw.innerHTML = '<h3>' + this.STR_IMAGE_SIZE + ':</h3>';
8049                 /*
8050                 var orgSize = '';
8051                 if ((height != oheight) || (width != owidth)) {
8052                     orgSize = '<span class="info">' + this.STR_IMAGE_ORIG_SIZE + '<br>'+ owidth +' x ' + oheight + '</span>';
8053                 }
8054                 */
8055                 hw.innerHTML += '<span tabIndex="-1"><input type="text" size="3" value="" id="' + this.get('id') + '_insertimage_width"> x <input type="text" size="3" value="" id="' + this.get('id') + '_insertimage_height"></span>';
8056                 cont.insertBefore(hw, cont.firstChild);
8057
8058                 Event.onAvailable(this.get('id') + '_insertimage_width', function() {
8059                     Event.on(this.get('id') + '_insertimage_width', 'blur', function() {
8060                         var value = parseInt(Dom.get(this.get('id') + '_insertimage_width').value, 10);
8061                         if (value > 5) {
8062                            this._defaultImageToolbar.editor_el.style.width = value + 'px';
8063                             //Removed moveWindow call so the window doesn't jump
8064                             //this.moveWindow();
8065                         }
8066                     }, this, true);
8067                 }, this, true);
8068                 Event.onAvailable(this.get('id') + '_insertimage_height', function() {
8069                     Event.on(this.get('id') + '_insertimage_height', 'blur', function() {
8070                         var value = parseInt(Dom.get(this.get('id') + '_insertimage_height').value, 10);
8071                         if (value > 5) {
8072                             this._defaultImageToolbar.editor_el.style.height = value + 'px';
8073                             //Removed moveWindow call so the window doesn't jump
8074                             //this.moveWindow();
8075                         }
8076                     }, this, true);
8077                 }, this, true);
8078
8079
8080                 tbar.on('colorPickerClicked', function(o) {
8081                     var size = '1', type = 'solid', color = 'black', el = this._defaultImageToolbar.editor_el;
8082
8083                     if (el.style.borderLeftWidth) {
8084                         size = parseInt(el.style.borderLeftWidth, 10);
8085                     }
8086                     if (el.style.borderLeftStyle) {
8087                         type = el.style.borderLeftStyle;
8088                     }
8089                     if (el.style.borderLeftColor) {
8090                         color = el.style.borderLeftColor;
8091                     }
8092                     var borderString = size + 'px ' + type + ' #' + o.color;
8093                     el.style.border = borderString;
8094                 }, this, true);
8095
8096                 tbar.on('buttonClick', function(o) {
8097                     var value = o.button.value,
8098                         el = this._defaultImageToolbar.editor_el,
8099                         borderString = '';
8100                     if (o.button.menucmd) {
8101                         value = o.button.menucmd;
8102                     }
8103                     var size = '1', type = 'solid', color = 'black';
8104
8105                     /* All border calcs are done on the left border
8106                         since our default interface only supports
8107                         one border size/type and color */
8108                     if (el.style.borderLeftWidth) {
8109                         size = parseInt(el.style.borderLeftWidth, 10);
8110                     }
8111                     if (el.style.borderLeftStyle) {
8112                         type = el.style.borderLeftStyle;
8113                     }
8114                     if (el.style.borderLeftColor) {
8115                         color = el.style.borderLeftColor;
8116                     }
8117                     switch(value) {
8118                         case 'bordersize':
8119                             if (this.browser.webkit && this._lastImage) {
8120                                 Dom.removeClass(this._lastImage, 'selected');
8121                                 this._lastImage = null;
8122                             }
8123
8124                             borderString = parseInt(o.button.value, 10) + 'px ' + type + ' ' + color;
8125                             el.style.border = borderString;
8126                             if (parseInt(o.button.value, 10) > 0) {
8127                                 tbar.enableButton('bordertype');
8128                                 tbar.enableButton('bordercolor');
8129                             } else {
8130                                 tbar.disableButton('bordertype');
8131                                 tbar.disableButton('bordercolor');
8132                             }
8133                             break;
8134                         case 'bordertype':
8135                             if (this.browser.webkit && this._lastImage) {
8136                                 Dom.removeClass(this._lastImage, 'selected');
8137                                 this._lastImage = null;
8138                             }
8139                             borderString = size + 'px ' + o.button.value + ' ' + color;
8140                             el.style.border = borderString;
8141                             break;
8142                         case 'right':
8143                         case 'left':
8144                             tbar.deselectAllButtons();
8145                             el.style.display = '';
8146                             el.align = o.button.value;
8147                             break;
8148                         case 'inline':
8149                             tbar.deselectAllButtons();
8150                             el.style.display = '';
8151                             el.align = '';
8152                             break;
8153                         case 'block':
8154                             tbar.deselectAllButtons();
8155                             el.style.display = 'block';
8156                             el.align = 'center';
8157                             break;
8158                         case 'padding':
8159                             var _button = tbar.getButtonById(o.button.id);
8160                             el.style.margin = _button.get('label') + 'px';
8161                             break;
8162                     }
8163                     tbar.selectButton(o.button.value);
8164                     if (value !== 'padding') {
8165                         this.moveWindow();
8166                     }
8167                 }, this, true);
8168
8169
8170
8171                 if (this.get('localFileWarning')) {
8172                     Event.on(this.get('id') + '_insertimage_link', 'blur', function() {
8173                         var url = Dom.get(this.get('id') + '_insertimage_link');
8174                         if (this._isLocalFile(url.value)) {
8175                             //Local File throw Warning
8176                             Dom.addClass(url, 'warning');
8177                             YAHOO.log('Local file reference found, show local warning', 'warn', 'Editor');
8178                             this.get('panel').setFooter(this.STR_LOCAL_FILE_WARNING);
8179                         } else {
8180                             Dom.removeClass(url, 'warning');
8181                             this.get('panel').setFooter(' ');
8182                             //Adobe AIR Code
8183                             if ((this.browser.webkit && !this.browser.webkit3 || this.browser.air) || this.browser.opera) {
8184                                 this.get('panel').setFooter(this.STR_IMAGE_COPY);
8185                             }
8186                         }
8187                     }, this, true);
8188                 }
8189
8190                 Event.on(this.get('id') + '_insertimage_url', 'blur', function() {
8191                     var url = Dom.get(this.get('id') + '_insertimage_url');
8192                     if (url.value && el) {
8193                         if (url.value == el.getAttribute('src', 2)) {
8194                             YAHOO.log('Images are the same, bail on blur handler', 'info', 'Editor');
8195                             return false;
8196                         }
8197                     }
8198                     YAHOO.log('Images are different, process blur handler', 'info', 'Editor');
8199                     if (this._isLocalFile(url.value)) {
8200                         //Local File throw Warning
8201                         Dom.addClass(url, 'warning');
8202                         YAHOO.log('Local file reference found, show local warning', 'warn', 'Editor');
8203                         this.get('panel').setFooter(this.STR_LOCAL_FILE_WARNING);
8204                     } else if (this.currentElement[0]) {
8205                         Dom.removeClass(url, 'warning');
8206                         this.get('panel').setFooter(' ');
8207                         //Adobe AIR Code
8208                         if ((this.browser.webkit && !this.browser.webkit3 || this.browser.air) || this.browser.opera) {
8209                             this.get('panel').setFooter(this.STR_IMAGE_COPY);
8210                         }
8211
8212                         if (url && url.value && (url.value != this.STR_IMAGE_HERE)) {
8213                             this.currentElement[0].setAttribute('src', url.value);
8214                             var self = this,
8215                                 img = new Image();
8216
8217                             img.onerror = function() {
8218                                 url.value = self.STR_IMAGE_HERE;
8219                                 img.setAttribute('src', self.get('blankimage'));
8220                                 self.currentElement[0].setAttribute('src', self.get('blankimage'));
8221                                 YAHOO.util.Dom.get(self.get('id') + '_insertimage_height').value = img.height;
8222                                 YAHOO.util.Dom.get(self.get('id') + '_insertimage_width').value = img.width;
8223                             };
8224                             var id = this.get('id');
8225                             window.setTimeout(function() {
8226                                 YAHOO.util.Dom.get(id + '_insertimage_height').value = img.height;
8227                                 YAHOO.util.Dom.get(id + '_insertimage_width').value = img.width;
8228                                 if (self.currentElement && self.currentElement[0]) {
8229                                     if (!self.currentElement[0]._height) {
8230                                         self.currentElement[0]._height = img.height;
8231                                     }
8232                                     if (!self.currentElement[0]._width) {
8233                                         self.currentElement[0]._width = img.width;
8234                                     }
8235                                 }
8236                                 //Removed moveWindow call so the window doesn't jump
8237                                 //self.moveWindow();
8238                             }, 800); //Bumped the timeout up to account for larger images..
8239
8240                             if (url.value != this.STR_IMAGE_HERE) {
8241                                 img.src = url.value;
8242                             }
8243                         }
8244                     }
8245                     }, this, true);
8246
8247
8248
8249                 this._windows.insertimage = {};
8250                 this._windows.insertimage.body = body;
8251                 //body.style.display = 'none';
8252                 this.get('panel').editor_form.appendChild(body);
8253                 this.fireEvent('windowInsertImageRender', { type: 'windowInsertImageRender', panel: this.get('panel'), body: body, toolbar: tbar });
8254                 return body;
8255         },
8256         /**
8257         * @private
8258         * @method _handleInsertImageClick
8259         * @description Opens the Image Properties Window when the insert Image button is clicked or an Image is Double Clicked.
8260         */
8261         _handleInsertImageClick: function() {
8262             if (this.get('limitCommands')) {
8263                 if (!this.toolbar.getButtonByValue('insertimage')) {
8264                     YAHOO.log('Toolbar Button for (insertimage) was not found, skipping exec.', 'info', 'Editor');
8265                     return false;
8266                 }
8267             }
8268             this.on('afterExecCommand', function() {
8269                 YAHOO.log('afterExecCommand :: _handleInsertImageClick', 'info', 'Editor');
8270                 var el = this.currentElement[0],
8271                     body = null,
8272                     link = '',
8273                     target = '',
8274                     tbar = null,
8275                     title = '',
8276                     src = '',
8277                     align = '',
8278                     height = 75,
8279                     width = 75,
8280                     padding = 0,
8281                     oheight = 0,
8282                     owidth = 0,
8283                     blankimage = false,
8284                     win = new YAHOO.widget.EditorWindow('insertimage', {
8285                         width: '415px'
8286                     });
8287
8288                 if (!el) {
8289                     el = this._getSelectedElement();
8290                 }
8291                 if (el) {
8292                     win.el = el;
8293                     if (el.getAttribute('src')) {
8294                         src = el.getAttribute('src', 2);
8295                         if (src.indexOf(this.get('blankimage')) != -1) {
8296                             src = this.STR_IMAGE_HERE;
8297                             blankimage = true;
8298                         }
8299                     }
8300                     if (el.getAttribute('alt', 2)) {
8301                         title = el.getAttribute('alt', 2);
8302                     }
8303                     if (el.getAttribute('title', 2)) {
8304                         title = el.getAttribute('title', 2);
8305                     }
8306
8307                     if (el.parentNode && this._isElement(el.parentNode, 'a')) {
8308                         link = el.parentNode.getAttribute('href', 2);
8309                         if (el.parentNode.getAttribute('target') !== null) {
8310                             target = el.parentNode.getAttribute('target');
8311                         }
8312                     }
8313                     height = parseInt(el.height, 10);
8314                     width = parseInt(el.width, 10);
8315                     if (el.style.height) {
8316                         height = parseInt(el.style.height, 10);
8317                     }
8318                     if (el.style.width) {
8319                         width = parseInt(el.style.width, 10);
8320                     }
8321                     if (el.style.margin) {
8322                         padding = parseInt(el.style.margin, 10);
8323                     }
8324                     if (!el._height) {
8325                         el._height = height;
8326                     }
8327                     if (!el._width) {
8328                         el._width = width;
8329                     }
8330                     oheight = el._height;
8331                     owidth = el._width;
8332                 }
8333                 if (this._windows.insertimage && this._windows.insertimage.body) {
8334                     body = this._windows.insertimage.body;
8335                     this._defaultImageToolbar.resetAllButtons();
8336                 } else {
8337                     body = this._renderInsertImageWindow();
8338                 }
8339
8340                 tbar = this._defaultImageToolbar;
8341                 tbar.editor_el = el;
8342
8343
8344                 var bsize = '0',
8345                     btype = 'solid';
8346
8347                 if (el.style.borderLeftWidth) {
8348                     bsize = parseInt(el.style.borderLeftWidth, 10);
8349                 }
8350                 if (el.style.borderLeftStyle) {
8351                     btype = el.style.borderLeftStyle;
8352                 }
8353                 var bs_button = tbar.getButtonByValue('bordersize'),
8354                     bSizeStr = ((parseInt(bsize, 10) > 0) ? '' : this.STR_NONE);
8355                 bs_button.set('label', '<span class="yui-toolbar-bordersize-' + bsize + '">' + bSizeStr + '</span>');
8356                 this._updateMenuChecked('bordersize', bsize, tbar);
8357
8358                 var bt_button = tbar.getButtonByValue('bordertype');
8359                 bt_button.set('label', '<span class="yui-toolbar-bordertype-' + btype + '">asdfa</span>');
8360                 this._updateMenuChecked('bordertype', btype, tbar);
8361                 if (parseInt(bsize, 10) > 0) {
8362                     tbar.enableButton(bt_button);
8363                     tbar.enableButton(bs_button);
8364                     tbar.enableButton('bordercolor');
8365                 }
8366
8367                 if ((el.align == 'right') || (el.align == 'left')) {
8368                     tbar.selectButton(el.align);
8369                 } else if (el.style.display == 'block') {
8370                     tbar.selectButton('block');
8371                 } else {
8372                     tbar.selectButton('inline');
8373                 }
8374                 if (parseInt(el.style.marginLeft, 10) > 0) {
8375                     tbar.getButtonByValue('padding').set('label', ''+parseInt(el.style.marginLeft, 10));
8376                 }
8377                 if (el.style.borderSize) {
8378                     tbar.selectButton('bordersize');
8379                     tbar.selectButton(parseInt(el.style.borderSize, 10));
8380                 }
8381                 tbar.getButtonByValue('padding').set('label', ''+padding);
8382
8383
8384
8385                 win.setHeader(this.STR_IMAGE_PROP_TITLE);
8386                 win.setBody(body);
8387                 //Adobe AIR Code
8388                 if ((this.browser.webkit && !this.browser.webkit3 || this.browser.air) || this.browser.opera) {
8389                     win.setFooter(this.STR_IMAGE_COPY);
8390                 }
8391                 this.openWindow(win);
8392                 Dom.get(this.get('id') + '_insertimage_url').value = src;
8393                 Dom.get(this.get('id') + '_insertimage_title').value = title;
8394                 Dom.get(this.get('id') + '_insertimage_link').value = link;
8395                 Dom.get(this.get('id') + '_insertimage_target').checked = ((target) ? true : false);
8396                 Dom.get(this.get('id') + '_insertimage_width').value = width;
8397                 Dom.get(this.get('id') + '_insertimage_height').value = height;
8398
8399
8400                 var orgSize = '';
8401                 if ((height != oheight) || (width != owidth)) {
8402                     var s = document.createElement('span');
8403                     s.className = 'info';
8404                     s.innerHTML = this.STR_IMAGE_ORIG_SIZE + ': ('+ owidth +' x ' + oheight + ')';
8405                     if (Dom.get(this.get('id') + '_insertimage_height').nextSibling) {
8406                         var old = Dom.get(this.get('id') + '_insertimage_height').nextSibling;
8407                         old.parentNode.removeChild(old);
8408                     }
8409                     Dom.get(this.get('id') + '_insertimage_height').parentNode.appendChild(s);
8410                 }
8411
8412                 this.toolbar.selectButton('insertimage');
8413                 var id = this.get('id');
8414                 window.setTimeout(function() {
8415                     try {
8416                         YAHOO.util.Dom.get(id + '_insertimage_url').focus();
8417                         if (blankimage) {
8418                             YAHOO.util.Dom.get(id + '_insertimage_url').select();
8419                         }
8420                     } catch (e) {}
8421                 }, 50);
8422
8423             });
8424         },
8425         /**
8426         * @private
8427         * @method _handleInsertImageWindowClose
8428         * @description Handles the closing of the Image Properties Window.
8429         */
8430         _handleInsertImageWindowClose: function() {
8431             var url = Dom.get(this.get('id') + '_insertimage_url'),
8432                 title = Dom.get(this.get('id') + '_insertimage_title'),
8433                 link = Dom.get(this.get('id') + '_insertimage_link'),
8434                 target = Dom.get(this.get('id') + '_insertimage_target'),
8435                 el = arguments[0].win.el;
8436
8437             if (url && url.value && (url.value != this.STR_IMAGE_HERE)) {
8438                 el.setAttribute('src', url.value);
8439                 el.setAttribute('title', title.value);
8440                 el.setAttribute('alt', title.value);
8441                 var par = el.parentNode;
8442                 if (link.value) {
8443                     var urlValue = link.value;
8444                     if ((urlValue.indexOf(':/'+'/') == -1) && (urlValue.substring(0,1) != '/') && (urlValue.substring(0, 6).toLowerCase() != 'mailto')) {
8445                         if ((urlValue.indexOf('@') != -1) && (urlValue.substring(0, 6).toLowerCase() != 'mailto')) {
8446                             //Found an @ sign, prefix with mailto:
8447                             urlValue = 'mailto:' + urlValue;
8448                         } else {
8449                             // :// not found adding
8450                             urlValue = 'http:/'+'/' + urlValue;
8451                         }
8452                     }
8453                     if (par && this._isElement(par, 'a')) {
8454                         par.setAttribute('href', urlValue);
8455                         if (target.checked) {
8456                             par.setAttribute('target', target.value);
8457                         } else {
8458                             par.setAttribute('target', '');
8459                         }
8460                     } else {
8461                         var _a = this._getDoc().createElement('a');
8462                         _a.setAttribute('href', urlValue);
8463                         if (target.checked) {
8464                             _a.setAttribute('target', target.value);
8465                         } else {
8466                             _a.setAttribute('target', '');
8467                         }
8468                         el.parentNode.replaceChild(_a, el);
8469                         _a.appendChild(el);
8470                     }
8471                 } else {
8472                     if (par && this._isElement(par, 'a')) {
8473                         par.parentNode.replaceChild(el, par);
8474                     }
8475                 }
8476             } else {
8477                 //No url/src given, remove the node from the document
8478                 el.parentNode.removeChild(el);
8479             }
8480             Dom.get(this.get('id') + '_insertimage_url').value = '';
8481             Dom.get(this.get('id') + '_insertimage_title').value = '';
8482             Dom.get(this.get('id') + '_insertimage_link').value = '';
8483             Dom.get(this.get('id') + '_insertimage_target').checked = false;
8484             Dom.get(this.get('id') + '_insertimage_width').value = 0;
8485             Dom.get(this.get('id') + '_insertimage_height').value = 0;
8486             this._defaultImageToolbar.resetAllButtons();
8487             this.currentElement = [];
8488             this.nodeChange();
8489         },
8490         /**
8491         * @property EDITOR_PANEL_ID
8492         * @description HTML id to give the properties window in the DOM.
8493         * @type String
8494         */
8495         EDITOR_PANEL_ID: '-panel',
8496         /**
8497         * @private
8498         * @method _renderPanel
8499         * @description Renders the panel used for Editor Windows to the document so we can start using it..
8500         * @return {<a href="YAHOO.widget.Overlay.html">YAHOO.widget.Overlay</a>}
8501         */
8502         _renderPanel: function() {
8503             var panelEl = document.createElement('div');
8504             Dom.addClass(panelEl, 'yui-editor-panel');
8505             panelEl.id = this.get('id') + this.EDITOR_PANEL_ID;
8506             panelEl.style.position = 'absolute';
8507             panelEl.style.top = '-9999px';
8508             panelEl.style.left = '-9999px';
8509             document.body.appendChild(panelEl);
8510             this.get('element_cont').insertBefore(panelEl, this.get('element_cont').get('firstChild'));
8511
8512
8513
8514             var panel = new YAHOO.widget.Overlay(this.get('id') + this.EDITOR_PANEL_ID, {
8515                     width: '300px',
8516                     iframe: true,
8517                     visible: false,
8518                     underlay: 'none',
8519                     draggable: false,
8520                     close: false
8521                 });
8522             this.set('panel', panel);
8523
8524             panel.setBody('---');
8525             panel.setHeader(' ');
8526             panel.setFooter(' ');
8527
8528
8529             var body = document.createElement('div');
8530             body.className = this.CLASS_PREFIX + '-body-cont';
8531             for (var b in this.browser) {
8532                 if (this.browser[b]) {
8533                     Dom.addClass(body, b);
8534                     break;
8535                 }
8536             }
8537             Dom.addClass(body, ((YAHOO.widget.Button && (this._defaultToolbar.buttonType == 'advanced')) ? 'good-button' : 'no-button'));
8538
8539             var _note = document.createElement('h3');
8540             _note.className = 'yui-editor-skipheader';
8541             _note.innerHTML = this.STR_CLOSE_WINDOW_NOTE;
8542             body.appendChild(_note);
8543             var form = document.createElement('fieldset');
8544             panel.editor_form = form;
8545
8546             body.appendChild(form);
8547             var _close = document.createElement('span');
8548             _close.innerHTML = 'X';
8549             _close.title = this.STR_CLOSE_WINDOW;
8550             _close.className = 'close';
8551
8552             Event.on(_close, 'click', this.closeWindow, this, true);
8553
8554             var _knob = document.createElement('span');
8555             _knob.innerHTML = '^';
8556             _knob.className = 'knob';
8557             panel.editor_knob = _knob;
8558
8559             var _header = document.createElement('h3');
8560             panel.editor_header = _header;
8561             _header.innerHTML = '<span></span>';
8562
8563             panel.setHeader(' '); //Clear the current header
8564             panel.appendToHeader(_header);
8565             _header.appendChild(_close);
8566             _header.appendChild(_knob);
8567             panel.setBody(' '); //Clear the current body
8568             panel.setFooter(' '); //Clear the current footer
8569             panel.appendToBody(body); //Append the new DOM node to it
8570
8571             Event.on(panel.element, 'click', function(ev) {
8572                 Event.stopPropagation(ev);
8573             });
8574
8575             var fireShowEvent = function() {
8576                 panel.bringToTop();
8577                 YAHOO.util.Dom.setStyle(this.element, 'display', 'block');
8578                 this._handleWindowInputs(false);
8579             };
8580             panel.showEvent.subscribe(fireShowEvent, this, true);
8581             panel.hideEvent.subscribe(function() {
8582                 this._handleWindowInputs(true);
8583             }, this, true);
8584             panel.renderEvent.subscribe(function() {
8585                 this._renderInsertImageWindow();
8586                 this._renderCreateLinkWindow();
8587                 this.fireEvent('windowRender', { type: 'windowRender', panel: panel });
8588                 this._handleWindowInputs(true);
8589             }, this, true);
8590
8591             if (this.DOMReady) {
8592                 this.get('panel').render();
8593             } else {
8594                 Event.onDOMReady(function() {
8595                     this.get('panel').render();
8596                 }, this, true);
8597             }
8598             return this.get('panel');
8599         },
8600         /**
8601         * @method _handleWindowInputs
8602         * @param {Boolean} disable The state to set all inputs in all Editor windows to. Defaults to: false.
8603         * @description Disables/Enables all fields inside Editor windows. Used in show/hide events to keep window fields from submitting when the parent form is submitted.
8604         */
8605         _handleWindowInputs: function(disable) {
8606             if (!Lang.isBoolean(disable)) {
8607                 disable = false;
8608             }
8609             var inputs = this.get('panel').element.getElementsByTagName('input');
8610             for (var i = 0; i < inputs.length; i++) {
8611                 try {
8612                     inputs[i].disabled = disable;
8613                 } catch (e) {}
8614             }
8615         },
8616         /**
8617         * @method openWindow
8618         * @param {<a href="YAHOO.widget.EditorWindow.html">YAHOO.widget.EditorWindow</a>} win A <a href="YAHOO.widget.EditorWindow.html">YAHOO.widget.EditorWindow</a> instance
8619         * @description Opens a new "window/panel"
8620         */
8621         openWindow: function(win) {
8622
8623             YAHOO.log('openWindow: ' + win.name, 'info', 'Editor');
8624             var self = this;
8625             window.setTimeout(function() {
8626                 self.toolbar.set('disabled', true); //Disable the toolbar when an editor window is open..
8627             }, 10);
8628             Event.on(document, 'keydown', this._closeWindow, this, true);
8629
8630             if (this.currentWindow) {
8631                 this.closeWindow();
8632             }
8633
8634             var xy = Dom.getXY(this.currentElement[0]),
8635             elXY = Dom.getXY(this.get('iframe').get('element')),
8636             panel = this.get('panel'),
8637             newXY = [(xy[0] + elXY[0] - 20), (xy[1] + elXY[1] + 10)],
8638             wWidth = (parseInt(win.attrs.width, 10) / 2),
8639             align = 'center',
8640             body = null;
8641
8642             this.fireEvent('beforeOpenWindow', { type: 'beforeOpenWindow', win: win, panel: panel });
8643
8644             var form = panel.editor_form;
8645
8646             var wins = this._windows;
8647             for (var b in wins) {
8648                 if (Lang.hasOwnProperty(wins, b)) {
8649                     if (wins[b] && wins[b].body) {
8650                         if (b == win.name) {
8651                             Dom.setStyle(wins[b].body, 'display', 'block');
8652                         } else {
8653                             Dom.setStyle(wins[b].body, 'display', 'none');
8654                         }
8655                     }
8656                 }
8657             }
8658
8659             if (this._windows[win.name].body) {
8660                 Dom.setStyle(this._windows[win.name].body, 'display', 'block');
8661                 form.appendChild(this._windows[win.name].body);
8662             } else {
8663                 if (Lang.isObject(win.body)) { //Assume it's a reference
8664                     form.appendChild(win.body);
8665                 } else { //Assume it's a string
8666                     var _tmp = document.createElement('div');
8667                     _tmp.innerHTML = win.body;
8668                     form.appendChild(_tmp);
8669                 }
8670             }
8671             panel.editor_header.firstChild.innerHTML = win.header;
8672             if (win.footer !== null) {
8673                 panel.setFooter(win.footer);
8674                 Dom.addClass(panel.footer, 'open');
8675             } else {
8676                 Dom.removeClass(panel.footer, 'open');
8677             }
8678             panel.cfg.setProperty('width', win.attrs.width);
8679
8680             this.currentWindow = win;
8681             this.moveWindow(true);
8682             panel.show();
8683             this.fireEvent('afterOpenWindow', { type: 'afterOpenWindow', win: win, panel: panel });
8684         },
8685         /**
8686         * @method moveWindow
8687         * @param {Boolean} force Boolean to tell it to move but not use any animation (Usually done the first time the window is loaded.)
8688         * @description Realign the window with the currentElement and reposition the knob above the panel.
8689         */
8690         moveWindow: function(force) {
8691             if (!this.currentWindow) {
8692                 return false;
8693             }
8694             var win = this.currentWindow,
8695                 xy = Dom.getXY(this.currentElement[0]),
8696                 elXY = Dom.getXY(this.get('iframe').get('element')),
8697                 panel = this.get('panel'),
8698                 //newXY = [(xy[0] + elXY[0] - 20), (xy[1] + elXY[1] + 10)],
8699                 newXY = [(xy[0] + elXY[0]), (xy[1] + elXY[1])],
8700                 wWidth = (parseInt(win.attrs.width, 10) / 2),
8701                 align = 'center',
8702                 orgXY = panel.cfg.getProperty('xy') || [0,0],
8703                 _knob = panel.editor_knob,
8704                 xDiff = 0,
8705                 yDiff = 0,
8706                 anim = false;
8707
8708
8709             newXY[0] = ((newXY[0] - wWidth) + 20);
8710             //Account for the Scroll bars in a scrolled editor window.
8711             newXY[0] = newXY[0] - Dom.getDocumentScrollLeft(this._getDoc());
8712             newXY[1] = newXY[1] - Dom.getDocumentScrollTop(this._getDoc());
8713
8714             if (this._isElement(this.currentElement[0], 'img')) {
8715                 if (this.currentElement[0].src.indexOf(this.get('blankimage')) != -1) {
8716                     newXY[0] = (newXY[0] + (75 / 2)); //Placeholder size
8717                     newXY[1] = (newXY[1] + 75); //Placeholder sizea
8718                 } else {
8719                     var w = parseInt(this.currentElement[0].width, 10);
8720                     var h = parseInt(this.currentElement[0].height, 10);
8721                     newXY[0] = (newXY[0] + (w / 2));
8722                     newXY[1] = (newXY[1] + h);
8723                 }
8724                 newXY[1] = newXY[1] + 15;
8725             } else {
8726                 var fs = Dom.getStyle(this.currentElement[0], 'fontSize');
8727                 if (fs && fs.indexOf && fs.indexOf('px') != -1) {
8728                     newXY[1] = newXY[1] + parseInt(Dom.getStyle(this.currentElement[0], 'fontSize'), 10) + 5;
8729                 } else {
8730                     newXY[1] = newXY[1] + 20;
8731                 }
8732             }
8733             if (newXY[0] < elXY[0]) {
8734                 newXY[0] = elXY[0] + 5;
8735                 align = 'left';
8736             }
8737
8738             if ((newXY[0] + (wWidth * 2)) > (elXY[0] + parseInt(this.get('iframe').get('element').clientWidth, 10))) {
8739                 newXY[0] = ((elXY[0] + parseInt(this.get('iframe').get('element').clientWidth, 10)) - (wWidth * 2) - 5);
8740                 align = 'right';
8741             }
8742
8743             try {
8744                 xDiff = (newXY[0] - orgXY[0]);
8745                 yDiff = (newXY[1] - orgXY[1]);
8746             } catch (e) {}
8747
8748
8749             var iTop = elXY[1] + parseInt(this.get('height'), 10);
8750             var iLeft = elXY[0] + parseInt(this.get('width'), 10);
8751             if (newXY[1] > iTop) {
8752                 newXY[1] = iTop;
8753             }
8754             if (newXY[0] > iLeft) {
8755                 newXY[0] = (iLeft / 2);
8756             }
8757
8758             //Convert negative numbers to positive so we can get the difference in distance
8759             xDiff = ((xDiff < 0) ? (xDiff * -1) : xDiff);
8760             yDiff = ((yDiff < 0) ? (yDiff * -1) : yDiff);
8761
8762             if (((xDiff > 10) || (yDiff > 10)) || force) { //Only move the window if it's supposed to move more than 10px or force was passed (new window)
8763                 var _knobLeft = 0,
8764                     elW = 0;
8765
8766                 if (this.currentElement[0].width) {
8767                     elW = (parseInt(this.currentElement[0].width, 10) / 2);
8768                 }
8769
8770                 var leftOffset = xy[0] + elXY[0] + elW;
8771                 _knobLeft = leftOffset - newXY[0];
8772                 //Check to see if the knob will go off either side & reposition it
8773                 if (_knobLeft > (parseInt(win.attrs.width, 10) - 1)) {
8774                     _knobLeft = ((parseInt(win.attrs.width, 10) - 30) - 1);
8775                 } else if (_knobLeft < 40) {
8776                     _knobLeft = 1;
8777                 }
8778                 if (isNaN(_knobLeft)) {
8779                     _knobLeft = 1;
8780                 }
8781                 if (force) {
8782                     if (_knob) {
8783                         _knob.style.left = _knobLeft + 'px';
8784                     }
8785                     //Removed Animation from a forced move..
8786                     panel.cfg.setProperty('xy', newXY);
8787                 } else {
8788                     if (this.get('animate')) {
8789                         anim = new YAHOO.util.Anim(panel.element, {}, 0.5, YAHOO.util.Easing.easeOut);
8790                         anim.attributes = {
8791                             top: {
8792                                 to: newXY[1]
8793                             },
8794                             left: {
8795                                 to: newXY[0]
8796                             }
8797                         };
8798                         anim.onComplete.subscribe(function() {
8799                             panel.cfg.setProperty('xy', newXY);
8800                         });
8801                         //We have to animate the iframe shim at the same time as the panel or we get scrollbar bleed ..
8802                         var iframeAnim = new YAHOO.util.Anim(panel.iframe, anim.attributes, 0.5, YAHOO.util.Easing.easeOut);
8803
8804                         var _knobAnim = new YAHOO.util.Anim(_knob, {
8805                             left: {
8806                                 to: _knobLeft
8807                             }
8808                         }, 0.6, YAHOO.util.Easing.easeOut);
8809                         anim.animate();
8810                         iframeAnim.animate();
8811                         _knobAnim.animate();
8812                     } else {
8813                         _knob.style.left = _knobLeft + 'px';
8814                         panel.cfg.setProperty('xy', newXY);
8815                     }
8816                 }
8817             }
8818         },
8819         /**
8820         * @private
8821         * @method _closeWindow
8822         * @description Close the currently open EditorWindow with the Escape key.
8823         * @param {Event} ev The keypress Event that we are trapping
8824         */
8825         _closeWindow: function(ev) {
8826             //if ((ev.charCode == 87) && ev.shiftKey && ev.ctrlKey) {
8827             if (this._checkKey(this._keyMap.CLOSE_WINDOW, ev)) {
8828                 if (this.currentWindow) {
8829                     this.closeWindow();
8830                 }
8831             }
8832         },
8833         /**
8834         * @method closeWindow
8835         * @description Close the currently open EditorWindow.
8836         */
8837         closeWindow: function(keepOpen) {
8838             YAHOO.log('closeWindow: ' + this.currentWindow.name, 'info', 'Editor');
8839             this.fireEvent('window' + this.currentWindow.name + 'Close', { type: 'window' + this.currentWindow.name + 'Close', win: this.currentWindow, el: this.currentElement[0] });
8840             this.fireEvent('closeWindow', { type: 'closeWindow', win: this.currentWindow });
8841             this.currentWindow = null;
8842             this.get('panel').hide();
8843             this.get('panel').cfg.setProperty('xy', [-900,-900]);
8844             this.get('panel').syncIframe(); //Needed to move the iframe with the hidden panel
8845             this.unsubscribeAll('afterExecCommand');
8846             this.toolbar.set('disabled', false); //enable the toolbar now that the window is closed
8847             this.toolbar.resetAllButtons();
8848             this.focus();
8849             Event.removeListener(document, 'keydown', this._closeWindow);
8850         },
8851
8852         /* {{{  Command Overrides - These commands are only over written when we are using the advanced version */
8853
8854         /**
8855         * @method cmd_undo
8856         * @description Pulls an item from the Undo stack and updates the Editor
8857         * @param value Value passed from the execCommand method
8858         */
8859         cmd_undo: function(value) {
8860             if (this._hasUndoLevel()) {
8861                 if (!this._undoLevel) {
8862                     this._undoLevel = this._undoCache.length;
8863                 }
8864                 this._undoLevel = (this._undoLevel - 1);
8865                 if (this._undoCache[this._undoLevel]) {
8866                     var html = this._getUndo(this._undoLevel);
8867                     this.setEditorHTML(html);
8868                 } else {
8869                     this._undoLevel = null;
8870                     this.toolbar.disableButton('undo');
8871                 }
8872             }
8873             return [false];
8874         },
8875
8876         /**
8877         * @method cmd_redo
8878         * @description Pulls an item from the Undo stack and updates the Editor
8879         * @param value Value passed from the execCommand method
8880         */
8881         cmd_redo: function(value) {
8882             this._undoLevel = this._undoLevel + 1;
8883             if (this._undoLevel >= this._undoCache.length) {
8884                 this._undoLevel = this._undoCache.length;
8885             }
8886             YAHOO.log(this._undoLevel + ' :: ' + this._undoCache.length, 'warn', 'SimpleEditor');
8887             if (this._undoCache[this._undoLevel]) {
8888                 var html = this._getUndo(this._undoLevel);
8889                 this.setEditorHTML(html);
8890             } else {
8891                 this.toolbar.disableButton('redo');
8892             }
8893             return [false];
8894         },
8895
8896         /**
8897         * @method cmd_heading
8898         * @param value Value passed from the execCommand method
8899         * @description This is an execCommand override method. It is called from execCommand when the execCommand('heading') is used.
8900         */
8901         cmd_heading: function(value) {
8902             var exec = true,
8903                 el = null,
8904                 action = 'heading',
8905                 _sel = this._getSelection(),
8906                 _selEl = this._getSelectedElement();
8907
8908             if (_selEl) {
8909                 _sel = _selEl;
8910             }
8911
8912             if (this.browser.ie) {
8913                 action = 'formatblock';
8914             }
8915             if (value == this.STR_NONE) {
8916                 if ((_sel && _sel.tagName && (_sel.tagName.toLowerCase().substring(0,1) == 'h')) || (_sel && _sel.parentNode && _sel.parentNode.tagName && (_sel.parentNode.tagName.toLowerCase().substring(0,1) == 'h'))) {
8917                     if (_sel.parentNode.tagName.toLowerCase().substring(0,1) == 'h') {
8918                         _sel = _sel.parentNode;
8919                     }
8920                     if (this._isElement(_sel, 'html')) {
8921                         return [false];
8922                     }
8923                     el = this._swapEl(_selEl, 'span', function(el) {
8924                         el.className = 'yui-non';
8925                     });
8926                     this._selectNode(el);
8927                     this.currentElement[0] = el;
8928                 }
8929                 exec = false;
8930             } else {
8931                 if (this._isElement(_selEl, 'h1') || this._isElement(_selEl, 'h2') || this._isElement(_selEl, 'h3') || this._isElement(_selEl, 'h4') || this._isElement(_selEl, 'h5') || this._isElement(_selEl, 'h6')) {
8932                     el = this._swapEl(_selEl, value);
8933                     this._selectNode(el);
8934                     this.currentElement[0] = el;
8935                 } else {
8936                     this._createCurrentElement(value);
8937                     this._selectNode(this.currentElement[0]);
8938                 }
8939                 exec = false;
8940             }
8941             return [exec, action];
8942         },
8943         /**
8944         * @method cmd_hiddenelements
8945         * @param value Value passed from the execCommand method
8946         * @description This is an execCommand override method. It is called from execCommand when the execCommand('hiddenelements') is used.
8947         */
8948         cmd_hiddenelements: function(value) {
8949             if (this._showingHiddenElements) {
8950                 //Don't auto highlight the hidden button
8951                 this._lastButton = null;
8952                 YAHOO.log('Enabling hidden CSS File', 'info', 'SimpleEditor');
8953                 this._showingHiddenElements = false;
8954                 this.toolbar.deselectButton('hiddenelements');
8955                 Dom.removeClass(this._getDoc().body, this.CLASS_HIDDEN);
8956             } else {
8957                 YAHOO.log('Disabling hidden CSS File', 'info', 'SimpleEditor');
8958                 this._showingHiddenElements = true;
8959                 Dom.addClass(this._getDoc().body, this.CLASS_HIDDEN);
8960                 this.toolbar.selectButton('hiddenelements');
8961             }
8962             return [false];
8963         },
8964         /**
8965         * @method cmd_removeformat
8966         * @param value Value passed from the execCommand method
8967         * @description This is an execCommand override method. It is called from execCommand when the execCommand('removeformat') is used.
8968         */
8969         cmd_removeformat: function(value) {
8970             var exec = true;
8971             /*
8972             * @knownissue Remove Format issue
8973             * @browser Safari 2.x
8974             * @description There is an issue here with Safari, that it may not always remove the format of the item that is selected.
8975             * Due to the way that Safari 2.x handles ranges, it is very difficult to determine what the selection holds.
8976             * So here we are making the best possible guess and acting on it.
8977             */
8978             if (this.browser.webkit && !this._getDoc().queryCommandEnabled('removeformat')) {
8979                 var _txt = this._getSelection()+'';
8980                 this._createCurrentElement('span');
8981                 this.currentElement[0].className = 'yui-non';
8982                 this.currentElement[0].innerHTML = _txt;
8983                 for (var i = 1; i < this.currentElement.length; i++) {
8984                     this.currentElement[i].parentNode.removeChild(this.currentElement[i]);
8985                 }
8986
8987                 exec = false;
8988             }
8989             return [exec];
8990         },
8991         /**
8992         * @method cmd_script
8993         * @param action action passed from the execCommand method
8994         * @param value Value passed from the execCommand method
8995         * @description This is a combined execCommand override method. It is called from the cmd_superscript and cmd_subscript methods.
8996         */
8997         cmd_script: function(action, value) {
8998             var exec = true, tag = action.toLowerCase().substring(0, 3),
8999                 _span = null, _selEl = this._getSelectedElement();
9000
9001             if (this.browser.webkit) {
9002                 YAHOO.log('Safari dom fun again (' + action + ')..', 'info', 'EditorSafari');
9003                 if (this._isElement(_selEl, tag)) {
9004                     YAHOO.log('we are a child of tag (' + tag + '), reverse process', 'info', 'EditorSafari');
9005                     _span = this._swapEl(this.currentElement[0], 'span', function(el) {
9006                         el.className = 'yui-non';
9007                     });
9008                     this._selectNode(_span);
9009                 } else {
9010                     this._createCurrentElement(tag);
9011                     var _sub = this._swapEl(this.currentElement[0], tag);
9012                     this._selectNode(_sub);
9013                     this.currentElement[0] = _sub;
9014                 }
9015                 exec = false;
9016             }
9017             return exec;
9018         },
9019         /**
9020         * @method cmd_superscript
9021         * @param value Value passed from the execCommand method
9022         * @description This is an execCommand override method. It is called from execCommand when the execCommand('superscript') is used.
9023         */
9024         cmd_superscript: function(value) {
9025             return [this.cmd_script('superscript', value)];
9026         },
9027         /**
9028         * @method cmd_subscript
9029         * @param value Value passed from the execCommand method
9030         * @description This is an execCommand override method. It is called from execCommand when the execCommand('subscript') is used.
9031         */
9032         cmd_subscript: function(value) {
9033             return [this.cmd_script('subscript', value)];
9034         },
9035         /**
9036         * @method cmd_indent
9037         * @param value Value passed from the execCommand method
9038         * @description This is an execCommand override method. It is called from execCommand when the execCommand('indent') is used.
9039         */
9040         cmd_indent: function(value) {
9041             var exec = true, selEl = this._getSelectedElement(), _bq = null;
9042
9043             //if (this.browser.webkit || this.browser.ie || this.browser.gecko) {
9044             //if (this.browser.webkit || this.browser.ie) {
9045             if (this.browser.ie) {
9046                 if (this._isElement(selEl, 'blockquote')) {
9047                     _bq = this._getDoc().createElement('blockquote');
9048                     _bq.innerHTML = selEl.innerHTML;
9049                     selEl.innerHTML = '';
9050                     selEl.appendChild(_bq);
9051                     this._selectNode(_bq);
9052                 } else {
9053                     _bq = this._getDoc().createElement('blockquote');
9054                     var html = this._getRange().htmlText;
9055                     _bq.innerHTML = html;
9056                     this._createCurrentElement('blockquote');
9057                     /*
9058                     for (var i = 0; i < this.currentElement.length; i++) {
9059                         _bq = this._getDoc().createElement('blockquote');
9060                         _bq.innerHTML = this.currentElement[i].innerHTML;
9061                         this.currentElement[i].parentNode.replaceChild(_bq, this.currentElement[i]);
9062                         this.currentElement[i] = _bq;
9063                     }
9064                     */
9065                     this.currentElement[0].parentNode.replaceChild(_bq, this.currentElement[0]);
9066                     this.currentElement[0] = _bq;
9067                     this._selectNode(this.currentElement[0]);
9068                 }
9069                 exec = false;
9070             } else {
9071                 value = 'blockquote';
9072             }
9073             return [exec, 'formatblock', value];
9074         },
9075         /**
9076         * @method cmd_outdent
9077         * @param value Value passed from the execCommand method
9078         * @description This is an execCommand override method. It is called from execCommand when the execCommand('outdent') is used.
9079         */
9080         cmd_outdent: function(value) {
9081             var exec = true, selEl = this._getSelectedElement(), _bq = null, _span = null;
9082             //if (this.browser.webkit || this.browser.ie || this.browser.gecko) {
9083             if (this.browser.webkit || this.browser.ie) {
9084             //if (this.browser.ie) {
9085                 selEl = this._getSelectedElement();
9086                 if (this._isElement(selEl, 'blockquote')) {
9087                     var par = selEl.parentNode;
9088                     if (this._isElement(selEl.parentNode, 'blockquote')) {
9089                         par.innerHTML = selEl.innerHTML;
9090                         this._selectNode(par);
9091                     } else {
9092                         _span = this._getDoc().createElement('span');
9093                         _span.innerHTML = selEl.innerHTML;
9094                         YAHOO.util.Dom.addClass(_span, 'yui-non');
9095                         par.replaceChild(_span, selEl);
9096                         this._selectNode(_span);
9097                     }
9098                 } else {
9099                     YAHOO.log('Can not outdent, we are not inside a blockquote', 'warn', 'Editor');
9100                 }
9101                 exec = false;
9102             } else {
9103                 value = false;
9104             }
9105             return [exec, 'outdent', value];
9106         },
9107         /**
9108         * @method cmd_justify
9109         * @param dir The direction to justify
9110         * @description This is a factory method for the justify family of commands.
9111         */
9112         cmd_justify: function(dir) {
9113             if (this.browser.ie) {
9114                 if (this._hasSelection()) {
9115                     this._createCurrentElement('span');
9116                     this._swapEl(this.currentElement[0], 'div', function(el) {
9117                         el.style.textAlign = dir;
9118                     });
9119
9120                     return [false];
9121                 }
9122             }
9123             return [true, 'justify' + dir, ''];
9124         },
9125         /**
9126         * @method cmd_justifycenter
9127         * @param value Value passed from the execCommand method
9128         * @description This is an execCommand override method. It is called from execCommand when the execCommand('justifycenter') is used.
9129         */
9130         cmd_justifycenter: function() {
9131             return [this.cmd_justify('center')];
9132         },
9133         /**
9134         * @method cmd_justifyleft
9135         * @param value Value passed from the execCommand method
9136         * @description This is an execCommand override method. It is called from execCommand when the execCommand('justifyleft') is used.
9137         */
9138         cmd_justifyleft: function() {
9139             return [this.cmd_justify('left')];
9140         },
9141         /**
9142         * @method cmd_justifyright
9143         * @param value Value passed from the execCommand method
9144         * @description This is an execCommand override method. It is called from execCommand when the execCommand('justifyright') is used.
9145         */
9146         cmd_justifyright: function() {
9147             return [this.cmd_justify('right')];
9148         },
9149         /* }}}*/
9150         /**
9151         * @method toString
9152         * @description Returns a string representing the editor.
9153         * @return {String}
9154         */
9155         toString: function() {
9156             var str = 'Editor';
9157             if (this.get && this.get('element_cont')) {
9158                 str = 'Editor (#' + this.get('element_cont').get('id') + ')' + ((this.get('disabled') ? ' Disabled' : ''));
9159             }
9160             return str;
9161         }
9162     });
9163 /**
9164 * @event beforeOpenWindow
9165 * @param {<a href="YAHOO.widget.EditorWindow.html">EditorWindow</a>} win The EditorWindow object
9166 * @param {Overlay} panel The Overlay object that is used to create the window.
9167 * @description Event fires before an Editor Window is opened. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
9168 * @type YAHOO.util.CustomEvent
9169 */
9170 /**
9171 * @event afterOpenWindow
9172 * @param {<a href="YAHOO.widget.EditorWindow.html">EditorWindow</a>} win The EditorWindow object
9173 * @param {Overlay} panel The Overlay object that is used to create the window.
9174 * @description Event fires after an Editor Window is opened. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
9175 * @type YAHOO.util.CustomEvent
9176 */
9177 /**
9178 * @event closeWindow
9179 * @param {<a href="YAHOO.widget.EditorWindow.html">EditorWindow</a>} win The EditorWindow object
9180 * @description Event fires after an Editor Window is closed. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
9181 * @type YAHOO.util.CustomEvent
9182 */
9183 /**
9184 * @event windowCMDOpen
9185 * @param {<a href="YAHOO.widget.EditorWindow.html">EditorWindow</a>} win The EditorWindow object
9186 * @param {Overlay} panel The Overlay object that is used to create the window.
9187 * @description Dynamic event fired when an <a href="YAHOO.widget.EditorWindow.html">EditorWindow</a> is opened.. The dynamic event is based on the name of the window. Example Window: createlink, opening this window would fire the windowcreatelinkOpen event. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
9188 * @type YAHOO.util.CustomEvent
9189 */
9190 /**
9191 * @event windowCMDClose
9192 * @param {<a href="YAHOO.widget.EditorWindow.html">EditorWindow</a>} win The EditorWindow object
9193 * @param {Overlay} panel The Overlay object that is used to create the window.
9194 * @description Dynamic event fired when an <a href="YAHOO.widget.EditorWindow.html">EditorWindow</a> is closed.. The dynamic event is based on the name of the window. Example Window: createlink, opening this window would fire the windowcreatelinkClose event. See <a href="YAHOO.util.Element.html#addListener">Element.addListener</a> for more information on listening for this event.
9195 * @type YAHOO.util.CustomEvent
9196 */
9197 /**
9198 * @event windowRender
9199 * @param {<a href="YAHOO.widget.EditorWindow.html">EditorWindow</a>} win The EditorWindow object
9200 * @param {Overlay} panel The Overlay object that is used to create the window.
9201 * @description Event fired when the initial Overlay is rendered. Can be used to manipulate the content of the panel.
9202 * @type YAHOO.util.CustomEvent
9203 */
9204 /**
9205 * @event windowInsertImageRender
9206 * @param {Overlay} panel The Overlay object that is used to create the window.
9207 * @param {HTMLElement} body The HTML element used as the body of the window..
9208 * @param {Toolbar} toolbar A reference to the toolbar object used inside this window.
9209 * @description Event fired when the pre render of the Insert Image window has finished.
9210 * @type YAHOO.util.CustomEvent
9211 */
9212 /**
9213 * @event windowCreateLinkRender
9214 * @param {Overlay} panel The Overlay object that is used to create the window.
9215 * @param {HTMLElement} body The HTML element used as the body of the window..
9216 * @description Event fired when the pre render of the Create Link window has finished.
9217 * @type YAHOO.util.CustomEvent
9218 */
9219
9220
9221
9222     /**
9223      * @description Class to hold Window information between uses. We use the same panel to show the windows, so using this will allow you to configure a window before it is shown.
9224      * This is what you pass to Editor.openWindow();. These parameters will not take effect until the openWindow() is called in the editor.
9225      * @class EditorWindow
9226      * @param {String} name The name of the window.
9227      * @param {Object} attrs Attributes for the window. Current attributes used are : height and width
9228     */
9229     YAHOO.widget.EditorWindow = function(name, attrs) {
9230         /**
9231         * @private
9232         * @property name
9233         * @description A unique name for the window
9234         */
9235         this.name = name.replace(' ', '_');
9236         /**
9237         * @private
9238         * @property attrs
9239         * @description The window attributes
9240         */
9241         this.attrs = attrs;
9242     };
9243
9244     YAHOO.widget.EditorWindow.prototype = {
9245         /**
9246         * @private
9247         * @property header
9248         * @description Holder for the header of the window, used in Editor.openWindow
9249         */
9250         header: null,
9251         /**
9252         * @private
9253         * @property body
9254         * @description Holder for the body of the window, used in Editor.openWindow
9255         */
9256         body: null,
9257         /**
9258         * @private
9259         * @property footer
9260         * @description Holder for the footer of the window, used in Editor.openWindow
9261         */
9262         footer: null,
9263         /**
9264         * @method setHeader
9265         * @description Sets the header for the window.
9266         * @param {String/HTMLElement} str The string or DOM reference to be used as the windows header.
9267         */
9268         setHeader: function(str) {
9269             this.header = str;
9270         },
9271         /**
9272         * @method setBody
9273         * @description Sets the body for the window.
9274         * @param {String/HTMLElement} str The string or DOM reference to be used as the windows body.
9275         */
9276         setBody: function(str) {
9277             this.body = str;
9278         },
9279         /**
9280         * @method setFooter
9281         * @description Sets the footer for the window.
9282         * @param {String/HTMLElement} str The string or DOM reference to be used as the windows footer.
9283         */
9284         setFooter: function(str) {
9285             this.footer = str;
9286         },
9287         /**
9288         * @method toString
9289         * @description Returns a string representing the EditorWindow.
9290         * @return {String}
9291         */
9292         toString: function() {
9293             return 'Editor Window (' + this.name + ')';
9294         }
9295     };
9296 })();
9297 YAHOO.register("editor", YAHOO.widget.Editor, {version: "2.7.0", build: "1799"});