Changeset 473 for trunk


Ignore:
Timestamp:
03/20/06 01:19:36 (14 years ago)
Author:
mokhet
Message:

apply BSD style coding for the whole file htmlarea.js as stated in ticket #711

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/htmlarea.js

    r472 r473  
    1616    --   * New code to be indented with 2 spaces ("soft tab"). 
    1717    --   * New code preferably uses BSD-Style Bracing 
    18     --      if(foo) 
     18    --      if ( foo ) 
    1919    --      { 
    2020    --        bar(); 
     
    4242}; 
    4343 
    44 if (typeof _editor_url == "string") { 
     44if ( typeof _editor_url == "string" ) 
     45{ 
    4546  // Leave exactly one backslash at the end of _editor_url 
    4647  _editor_url = _editor_url.replace(/\x2f*$/, '/'); 
    47 } else { 
     48} 
     49else 
     50{ 
    4851  alert("WARNING: _editor_url is not set!  You should set this variable to the editor files path; it should preferably be an absolute path, like in '/htmlarea/', but it can be relative if you prefer.  Further we will try to load the editor files correctly but we'll probably fail."); 
    4952  _editor_url = ''; 
     
    5154 
    5255// make sure we have a language 
    53 if (typeof _editor_lang == "string") { 
     56if ( typeof _editor_lang == "string" ) 
     57{ 
    5458  _editor_lang = _editor_lang.toLowerCase(); 
    55 } else { 
     59} 
     60else 
     61{ 
    5662  _editor_lang = "en"; 
    5763} 
    5864 
    5965// skin stylesheet to load 
    60 if (!(typeof _editor_skin == "string")) { 
     66if ( typeof _editor_skin !== "string" ) 
     67{ 
    6168  _editor_skin = ""; 
    6269} 
    6370 
    64 var __htmlareas = [ ]; 
     71var __htmlareas = []; 
    6572 
    6673// browser identification 
    67 HTMLArea.agt = navigator.userAgent.toLowerCase(); 
     74HTMLArea.agt       = navigator.userAgent.toLowerCase(); 
    6875HTMLArea.is_ie     = ((HTMLArea.agt.indexOf("msie") != -1) && (HTMLArea.agt.indexOf("opera") == -1)); 
    6976HTMLArea.is_opera  = (HTMLArea.agt.indexOf("opera") != -1); 
     
    7784function HTMLArea(textarea, config) 
    7885{ 
    79   if(!textarea) { throw("Tried to create HTMLArea without textarea specified."); } 
    80  
    81   if (HTMLArea.checkSupportedBrowser()) { 
    82     if (typeof config == "undefined") { 
     86  if ( !textarea ) 
     87  { 
     88    throw("Tried to create HTMLArea without textarea specified."); 
     89  } 
     90 
     91  if ( HTMLArea.checkSupportedBrowser() ) 
     92  { 
     93    if ( typeof config == "undefined" ) 
     94    { 
    8395      this.config = new HTMLArea.Config(); 
    84     } else { 
     96    } 
     97    else 
     98    { 
    8599      this.config = config; 
    86100    } 
    87101    this._htmlArea = null; 
    88102 
    89     if(typeof textarea != 'object') 
     103    if ( typeof textarea != 'object' ) 
    90104    { 
    91105      textarea = HTMLArea.getElementById('textarea', textarea); 
     
    96110    this._initial_ta_size = 
    97111    { 
    98       w: textarea.style.width ? textarea.style.width   : (textarea.offsetWidth ? (textarea.offsetWidth + 'px') : (textarea.cols+'em')), 
    99       h: textarea.style.height ? textarea.style.height : (textarea.offsetHeight ? (textarea.offsetHeight + 'px') : (textarea.rows+'em')) 
     112      w: textarea.style.width  ? textarea.style.width  : ( textarea.offsetWidth  ? ( textarea.offsetWidth  + 'px' ) : ( textarea.cols + 'em') ), 
     113      h: textarea.style.height ? textarea.style.height : ( textarea.offsetHeight ? ( textarea.offsetHeight + 'px' ) : ( textarea.rows + 'em') ) 
    100114    }; 
    101115    // Create the loading message elements 
    102     if (this.config.showLoading) 
     116    if ( this.config.showLoading ) 
    103117    { 
    104118      // Create and show the main loading message and the sub loading message for details of loading actions 
     
    114128        loading_message.style.width = textarea.offsetWidth + 'px'; 
    115129      } 
    116       catch (e) 
     130      catch (ex) 
    117131      { 
    118132        // offsetWidth seems not set, so let's use this._initial_ta_size.w, but sometimes it may be too huge width 
     
    149163    __htmlareas[this.__htmlarea_id_num] = this; 
    150164 
    151     this._notifyListeners = { }; 
     165    this._notifyListeners = {}; 
    152166 
    153167    // Panels 
     
    180194    }; 
    181195 
    182     for(var i in panels) 
    183     { 
    184       if (!panels[i].container) { continue; } // prevent iterating over wrong type 
     196    for ( var i in panels ) 
     197    { 
     198      if(!panels[i].container) { continue; } // prevent iterating over wrong type 
    185199      panels[i].div = panels[i].container; // legacy 
    186200      panels[i].container.className = 'panels ' + i; 
     
    195209} 
    196210 
    197 HTMLArea.onload = function(){}; 
    198 HTMLArea.init = function() { 
    199     HTMLArea.onload(); 
    200 }; 
    201  
     211HTMLArea.onload = function() { }; 
     212HTMLArea.init = function() { HTMLArea.onload(); }; 
    202213 
    203214// cache some regexps 
    204 HTMLArea.RE_tagName = /(<\/|<)\s*([^ \t\n>]+)/ig; 
    205 HTMLArea.RE_doctype = /(<!doctype((.|\n)*?)>)\n?/i; 
    206 HTMLArea.RE_head    = /<head>((.|\n)*?)<\/head>/i; 
    207 HTMLArea.RE_body    = /<body[^>]*>((.|\n|\r|\t)*?)<\/body>/i; 
     215HTMLArea.RE_tagName  = /(<\/|<)\s*([^ \t\n>]+)/ig; 
     216HTMLArea.RE_doctype  = /(<!doctype((.|\n)*?)>)\n?/i; 
     217HTMLArea.RE_head     = /<head>((.|\n)*?)<\/head>/i; 
     218HTMLArea.RE_body     = /<body[^>]*>((.|\n|\r|\t)*?)<\/body>/i; 
    208219HTMLArea.RE_Specials = /([\/\^$*+?.()|{}[\]])/g; 
    209220HTMLArea.RE_email    = /[_a-zA-Z\d\-\.]{3,}@[_a-zA-Z\d\-]{2,}(\.[_a-zA-Z\d\-]{2,})+/i; 
    210221HTMLArea.RE_url      = /(https?:\/\/)?(([a-z0-9_]+:[a-z0-9_]+@)?[a-z0-9_-]{2,}(\.[a-z0-9_-]{2,}){2,}(:[0-9]+)?(\/\S+)*)/i; 
    211222 
    212 HTMLArea.Config = function () { 
     223HTMLArea.Config = function() 
     224{ 
    213225  var cfg = this; 
    214226  this.version = HTMLArea.version.Revision; 
     
    275287 
    276288  // external stylesheets to load (REFERENCE THESE ABSOLUTELY) 
    277   this.pageStyleSheets = [ ]; 
     289  this.pageStyleSheets = []; 
    278290 
    279291  // specify a base href for relative links 
    280   this.baseHref  = null; 
     292  this.baseHref = null; 
    281293 
    282294  // we can strip the base href out of relative links to leave them relative, reason for this 
     
    299311  //  more than 7bits into UNICODE decimal entity references (actually it will convert anything 
    300312  //  below <space> (chr 20) except cr, lf and tab and above <tilde> (~, chr 7E)) 
    301   this.sevenBitClean  = false; 
     313  this.sevenBitClean = false; 
    302314 
    303315  // sometimes we want to be able to replace some string in the html comng in and going out 
     
    306318  //  your absolute links, your external string might be some special code, say "{server_url}" 
    307319  //  an you say that the internal represenattion of that should be http://your.server/ 
    308   this.specialReplacements = { }; // { 'external_string' : 'internal_string' } 
     320  this.specialReplacements = {}; // { 'external_string' : 'internal_string' } 
    309321 
    310322  // set to true if you want Word code to be cleaned upon Paste 
     
    365377 
    366378 
    367   this.fontname = { 
    368     "&mdash; font &mdash;":         '', 
    369     "Arial":       'arial,helvetica,sans-serif', 
     379  this.fontname = 
     380  { 
     381    "&mdash; font &mdash;": '', 
     382    "Arial":             'arial,helvetica,sans-serif', 
    370383    "Courier New":         'courier new,courier,monospace', 
    371     "Georgia":     'georgia,times new roman,times,serif', 
    372     "Tahoma":      'tahoma,arial,helvetica,sans-serif', 
     384    "Georgia":         'georgia,times new roman,times,serif', 
     385    "Tahoma":            'tahoma,arial,helvetica,sans-serif', 
    373386    "Times New Roman": 'times new roman,times,serif', 
    374     "Verdana":     'verdana,arial,helvetica,sans-serif', 
    375     "impact":      'impact', 
    376     "WingDings":           'wingdings' 
     387    "Verdana":         'verdana,arial,helvetica,sans-serif', 
     388    "impact":            'impact', 
     389    "WingDings":             'wingdings' 
    377390  }; 
    378391 
    379   this.fontsize = { 
    380     "&mdash; size &mdash;"  : "", 
     392  this.fontsize = 
     393  { 
     394    "&mdash; size &mdash;": "", 
    381395    "1 (8 pt)" : "1", 
    382396    "2 (10 pt)": "2", 
     
    388402  }; 
    389403 
    390   this.formatblock = { 
    391     "&mdash; format &mdash;"  : "", 
     404  this.formatblock = 
     405  { 
     406    "&mdash; format &mdash;": "", 
    392407    "Heading 1": "h1", 
    393408    "Heading 2": "h2", 
     
    403418  this.customSelects = {}; 
    404419 
    405   function cut_copy_paste(e, cmd, obj) { 
    406     e.execCommand(cmd); 
    407   } 
     420  function cut_copy_paste(e, cmd, obj) { e.execCommand(cmd); } 
    408421 
    409422  this.debug = true; 
    410423 
    411   this.URIs = { 
     424  this.URIs = 
     425  { 
    412426   "blank": "popups/blank.html", 
    413427   "link": "link.html", 
     
    439453  //            See images/buttons_main.gif to see how it's done. 
    440454  //    - Enabled in text mode: if false the button gets disabled for text-only mode; otherwise enabled all the time. 
    441   this.btnList = { 
    442     bold:          [ "Bold",   HTMLArea._lc({key: 'button_bold', string: ["ed_buttons_main.gif",3,2]}, 'HTMLArea'), false, function(e) {e.execCommand("bold");} ], 
    443     italic:        [ "Italic", HTMLArea._lc({key: 'button_italic', string: ["ed_buttons_main.gif",2,2]}, 'HTMLArea'), false, function(e) {e.execCommand("italic");} ], 
    444     underline:     [ "Underline", HTMLArea._lc({key: 'button_underline', string: ["ed_buttons_main.gif",2,0]}, 'HTMLArea'), false, function(e) {e.execCommand("underline");} ], 
    445     strikethrough: [ "Strikethrough", HTMLArea._lc({key: 'button_strikethrough', string: ["ed_buttons_main.gif",3,0]}, 'HTMLArea'), false, function(e) {e.execCommand("strikethrough");} ], 
    446     subscript:     [ "Subscript", HTMLArea._lc({key: 'button_subscript', string: ["ed_buttons_main.gif",3,1]}, 'HTMLArea'), false, function(e) {e.execCommand("subscript");} ], 
    447     superscript:   [ "Superscript", HTMLArea._lc({key: 'button_superscript', string: ["ed_buttons_main.gif",2,1]}, 'HTMLArea'), false, function(e) {e.execCommand("superscript");} ], 
    448  
    449     justifyleft:   [ "Justify Left", ["ed_buttons_main.gif",0,0], false, function(e) {e.execCommand("justifyleft");} ], 
    450     justifycenter: [ "Justify Center", ["ed_buttons_main.gif",1,1], false, function(e){e.execCommand("justifycenter");}], 
    451     justifyright: [ "Justify Right", ["ed_buttons_main.gif",1,0], false, function(e) {e.execCommand("justifyright");} ], 
    452     justifyfull: [ "Justify Full", ["ed_buttons_main.gif",0,1], false, function(e) {e.execCommand("justifyfull");} ], 
    453  
    454  
    455     orderedlist: [ "Ordered List", ["ed_buttons_main.gif",0,3], false, function(e) {e.execCommand("insertorderedlist");} ], 
    456     unorderedlist: [ "Bulleted List", ["ed_buttons_main.gif",1,3], false, function(e) {e.execCommand("insertunorderedlist");} ], 
    457     insertorderedlist: [ "Ordered List", ["ed_buttons_main.gif",0,3], false, function(e) {e.execCommand("insertorderedlist");} ], 
    458     insertunorderedlist: [ "Bulleted List", ["ed_buttons_main.gif",1,3], false, function(e) {e.execCommand("insertunorderedlist");} ], 
    459  
    460     outdent: [ "Decrease Indent", ["ed_buttons_main.gif",1,2], false, function(e) {e.execCommand("outdent");} ], 
    461     indent: [ "Increase Indent",["ed_buttons_main.gif",0,2], false, function(e) {e.execCommand("indent");} ], 
    462     forecolor: [ "Font Color", ["ed_buttons_main.gif",3,3], false, function(e) {e.execCommand("forecolor");} ], 
    463     hilitecolor: [ "Background Color", ["ed_buttons_main.gif",2,3], false, function(e) {e.execCommand("hilitecolor");} ], 
    464  
    465     undo: [ "Undoes your last action", ["ed_buttons_main.gif",4,2], false, function(e) {e.execCommand("undo");} ], 
    466     redo: [ "Redoes your last action", ["ed_buttons_main.gif",5,2], false, function(e) {e.execCommand("redo");} ], 
     455  this.btnList = 
     456  { 
     457    bold: [ "Bold", HTMLArea._lc({key: 'button_bold', string: ["ed_buttons_main.gif",3,2]}, 'HTMLArea'), false, function(e) { e.execCommand("bold"); } ], 
     458    italic: [ "Italic", HTMLArea._lc({key: 'button_italic', string: ["ed_buttons_main.gif",2,2]}, 'HTMLArea'), false, function(e) { e.execCommand("italic"); } ], 
     459    underline: [ "Underline", HTMLArea._lc({key: 'button_underline', string: ["ed_buttons_main.gif",2,0]}, 'HTMLArea'), false, function(e) { e.execCommand("underline"); } ], 
     460    strikethrough: [ "Strikethrough", HTMLArea._lc({key: 'button_strikethrough', string: ["ed_buttons_main.gif",3,0]}, 'HTMLArea'), false, function(e) { e.execCommand("strikethrough"); } ], 
     461    subscript: [ "Subscript", HTMLArea._lc({key: 'button_subscript', string: ["ed_buttons_main.gif",3,1]}, 'HTMLArea'), false, function(e) { e.execCommand("subscript"); } ], 
     462    superscript: [ "Superscript", HTMLArea._lc({key: 'button_superscript', string: ["ed_buttons_main.gif",2,1]}, 'HTMLArea'), false, function(e) { e.execCommand("superscript"); } ], 
     463 
     464    justifyleft: [ "Justify Left", ["ed_buttons_main.gif",0,0], false, function(e) { e.execCommand("justifyleft"); } ], 
     465    justifycenter: [ "Justify Center", ["ed_buttons_main.gif",1,1], false, function(e){ e.execCommand("justifycenter"); } ], 
     466    justifyright: [ "Justify Right", ["ed_buttons_main.gif",1,0], false, function(e) { e.execCommand("justifyright"); } ], 
     467    justifyfull: [ "Justify Full", ["ed_buttons_main.gif",0,1], false, function(e) { e.execCommand("justifyfull"); } ], 
     468 
     469    orderedlist: [ "Ordered List", ["ed_buttons_main.gif",0,3], false, function(e) { e.execCommand("insertorderedlist"); } ], 
     470    unorderedlist: [ "Bulleted List", ["ed_buttons_main.gif",1,3], false, function(e) { e.execCommand("insertunorderedlist"); } ], 
     471    insertorderedlist: [ "Ordered List", ["ed_buttons_main.gif",0,3], false, function(e) { e.execCommand("insertorderedlist"); } ], 
     472    insertunorderedlist: [ "Bulleted List", ["ed_buttons_main.gif",1,3], false, function(e) { e.execCommand("insertunorderedlist"); } ], 
     473 
     474    outdent: [ "Decrease Indent", ["ed_buttons_main.gif",1,2], false, function(e) { e.execCommand("outdent"); } ], 
     475    indent: [ "Increase Indent",["ed_buttons_main.gif",0,2], false, function(e) { e.execCommand("indent"); } ], 
     476    forecolor: [ "Font Color", ["ed_buttons_main.gif",3,3], false, function(e) { e.execCommand("forecolor"); } ], 
     477    hilitecolor: [ "Background Color", ["ed_buttons_main.gif",2,3], false, function(e) { e.execCommand("hilitecolor"); } ], 
     478 
     479    undo: [ "Undoes your last action", ["ed_buttons_main.gif",4,2], false, function(e) { e.execCommand("undo"); } ], 
     480    redo: [ "Redoes your last action", ["ed_buttons_main.gif",5,2], false, function(e) { e.execCommand("redo"); } ], 
    467481    cut: [ "Cut selection", ["ed_buttons_main.gif",5,0], false, cut_copy_paste ], 
    468482    copy: [ "Copy selection", ["ed_buttons_main.gif",4,0], false, cut_copy_paste ], 
     
    470484    selectall: [ "Select all", "ed_selectall.gif", false, function(e) {e.execCommand("selectall");} ], 
    471485 
    472  
    473     inserthorizontalrule: [ "Horizontal Rule", ["ed_buttons_main.gif",6,0], false, function(e) {e.execCommand("inserthorizontalrule");} ], 
    474     createlink: [ "Insert Web Link", ["ed_buttons_main.gif",6,1], false, function(e) {e._createLink();} ], 
    475     insertimage: [ "Insert/Modify Image", ["ed_buttons_main.gif",6,3], false, function(e) {e.execCommand("insertimage");} ], 
    476     inserttable: [ "Insert Table", ["ed_buttons_main.gif",6,2], false, function(e) {e.execCommand("inserttable");} ], 
    477  
    478  
    479     htmlmode: [ "Toggle HTML Source", ["ed_buttons_main.gif",7,0], true, function(e) {e.execCommand("htmlmode");} ], 
    480     toggleborders: [ "Toggle Borders", ["ed_buttons_main.gif",7,2], false, function(e) {e._toggleBorders();} ], 
    481     print: [ "Print document", ["ed_buttons_main.gif",8,1], false, function(e) {if (HTMLArea.is_gecko) {e._iframe.contentWindow.print();} else {e.focusEditor(); print();}} ], 
    482     saveas: [ "Save as", "ed_saveas.gif", false, function(e) {e.execCommand("saveas",false,"noname.htm");} ], 
    483     about: [ "About this editor", ["ed_buttons_main.gif",8,2], true, function(e) {e.execCommand("about");} ], 
    484     showhelp: [ "Help using editor", ["ed_buttons_main.gif",9,2], true, function(e) {e.execCommand("showhelp");} ], 
    485  
    486     splitblock:    [ "Split Block", "ed_splitblock.gif", false, function(e) {e._splitBlock();} ], 
    487     lefttoright: [ "Direction left to right", ["ed_buttons_main.gif",0,4], false, function(e) {e.execCommand("lefttoright");} ], 
    488     righttoleft: [ "Direction right to left", ["ed_buttons_main.gif",1,4], false, function(e) {e.execCommand("righttoleft");} ], 
    489     overwrite: [ "Insert/Overwrite", "ed_overwrite.gif", false, function(e) {e.execCommand("overwrite");} ], 
    490  
    491     wordclean:     [ "MS Word Cleaner", ["ed_buttons_main.gif",5,3], false, function(e) {e._wordClean();} ], 
    492     clearfonts:    [ "Clear Inline Font Specifications", ["ed_buttons_main.gif",5,4], true, function(e) {e._clearFonts();} ], 
    493     removeformat:  [ "Remove formatting", ["ed_buttons_main.gif",4,4], false, function(e) {e.execCommand("removeformat");} ], 
    494     killword:      [ "Clear MSOffice tags", ["ed_buttons_main.gif",4,3], false, function(e) {e.execCommand("killword");} ] 
    495  
     486    inserthorizontalrule: [ "Horizontal Rule", ["ed_buttons_main.gif",6,0], false, function(e) { e.execCommand("inserthorizontalrule"); } ], 
     487    createlink: [ "Insert Web Link", ["ed_buttons_main.gif",6,1], false, function(e) { e._createLink(); } ], 
     488    insertimage: [ "Insert/Modify Image", ["ed_buttons_main.gif",6,3], false, function(e) { e.execCommand("insertimage"); } ], 
     489    inserttable: [ "Insert Table", ["ed_buttons_main.gif",6,2], false, function(e) { e.execCommand("inserttable"); } ], 
     490 
     491    htmlmode: [ "Toggle HTML Source", ["ed_buttons_main.gif",7,0], true, function(e) { e.execCommand("htmlmode"); } ], 
     492    toggleborders: [ "Toggle Borders", ["ed_buttons_main.gif",7,2], false, function(e) { e._toggleBorders(); } ], 
     493    print: [ "Print document", ["ed_buttons_main.gif",8,1], false, function(e) { if(HTMLArea.is_gecko) {e._iframe.contentWindow.print(); } else { e.focusEditor(); print(); } } ], 
     494    saveas: [ "Save as", "ed_saveas.gif", false, function(e) { e.execCommand("saveas",false,"noname.htm"); } ], 
     495    about: [ "About this editor", ["ed_buttons_main.gif",8,2], true, function(e) { e.execCommand("about"); } ], 
     496    showhelp: [ "Help using editor", ["ed_buttons_main.gif",9,2], true, function(e) { e.execCommand("showhelp"); } ], 
     497 
     498    splitblock: [ "Split Block", "ed_splitblock.gif", false, function(e) { e._splitBlock(); } ], 
     499    lefttoright: [ "Direction left to right", ["ed_buttons_main.gif",0,4], false, function(e) { e.execCommand("lefttoright"); } ], 
     500    righttoleft: [ "Direction right to left", ["ed_buttons_main.gif",1,4], false, function(e) { e.execCommand("righttoleft"); } ], 
     501    overwrite: [ "Insert/Overwrite", "ed_overwrite.gif", false, function(e) { e.execCommand("overwrite"); } ], 
     502 
     503    wordclean: [ "MS Word Cleaner", ["ed_buttons_main.gif",5,3], false, function(e) { e._wordClean(); } ], 
     504    clearfonts: [ "Clear Inline Font Specifications", ["ed_buttons_main.gif",5,4], true, function(e) { e._clearFonts(); } ], 
     505    removeformat: [ "Remove formatting", ["ed_buttons_main.gif",4,4], false, function(e) { e.execCommand("removeformat"); } ], 
     506    killword: [ "Clear MSOffice tags", ["ed_buttons_main.gif",4,3], false, function(e) { e.execCommand("killword"); } ] 
    496507  }; 
     508 
    497509  /* ADDING CUSTOM BUTTONS 
    498510   * --------------------- 
     
    519531   */ 
    520532  // initialize tooltips from the I18N module and generate correct image path 
    521   for (var i in this.btnList) { 
     533  for ( var i in this.btnList ) 
     534  { 
    522535    var btn = this.btnList[i]; 
    523     if (typeof btn != 'object') { continue; } // prevent iterating over wrong type 
    524     if (typeof btn[1] != 'string') 
     536    // prevent iterating over wrong type 
     537    if ( typeof btn != 'object' ) 
     538    { 
     539      continue; 
     540    }  
     541    if ( typeof btn[1] != 'string' ) 
    525542    { 
    526543      btn[1][0] = _editor_url + this.imgURL + btn[1][0]; 
     
    552569 *    }); 
    553570 */ 
    554 HTMLArea.Config.prototype.registerButton = function(id, tooltip, image, textMode, action, context) { 
     571HTMLArea.Config.prototype.registerButton = function(id, tooltip, image, textMode, action, context) 
     572{ 
    555573  var the_id; 
    556   if (typeof id == "string") { 
     574  if ( typeof id == "string" ) 
     575  { 
    557576    the_id = id; 
    558   } else if (typeof id == "object") { 
     577  } 
     578  else if ( typeof id == "object" ) 
     579  { 
    559580    the_id = id.id; 
    560   } else { 
     581  } 
     582  else 
     583  { 
    561584    alert("ERROR [HTMLArea.Config::registerButton]:\ninvalid arguments"); 
    562585    return false; 
    563586  } 
    564587  // check for existing id 
    565   if (typeof this.customSelects[the_id] != "undefined") { 
     588//  if(typeof this.customSelects[the_id] != "undefined") 
     589//  { 
    566590    // alert("WARNING [HTMLArea.Config::registerDropdown]:\nA dropdown with the same ID already exists."); 
    567   } 
    568   if (typeof this.btnList[the_id] != "undefined") { 
     591//  } 
     592//  if(typeof this.btnList[the_id] != "undefined") { 
    569593    // alert("WARNING [HTMLArea.Config::registerDropdown]:\nA button with the same ID already exists."); 
    570   } 
    571   switch (typeof id) { 
    572       case "string": this.btnList[id] = [ tooltip, image, textMode, action, context ]; break; 
    573       case "object": this.btnList[id.id] = [ id.tooltip, id.image, id.textMode, id.action, id.context ]; break; 
     594//  } 
     595  switch ( typeof id ) 
     596  { 
     597    case "string": 
     598      this.btnList[id] = [ tooltip, image, textMode, action, context ]; 
     599    break; 
     600    case "object": 
     601      this.btnList[id.id] = [ id.tooltip, id.image, id.textMode, id.action, id.context ]; 
     602    break; 
    574603  } 
    575604}; 
     
    577606HTMLArea.prototype.registerPanel = function(side, object) 
    578607{ 
    579   if(!side) { side = 'right'; } 
     608  if ( !side ) 
     609  { 
     610    side = 'right'; 
     611  } 
    580612  this.setLoadingMessage('Register panel ' + side); 
    581613  var panel = this.addPanel(side); 
    582   if(object) 
     614  if ( object ) 
    583615  { 
    584616    object.drawPanelIn(panel); 
     
    592624 * FIXME: add example 
    593625 */ 
    594 HTMLArea.Config.prototype.registerDropdown = function(object) { 
     626HTMLArea.Config.prototype.registerDropdown = function(object) 
     627{ 
    595628  // check for existing id 
    596   if (typeof this.customSelects[object.id] != "undefined") { 
     629//  if ( typeof this.customSelects[object.id] != "undefined" ) 
     630//  { 
    597631    // alert("WARNING [HTMLArea.Config::registerDropdown]:\nA dropdown with the same ID already exists."); 
    598   } 
    599   if (typeof this.btnList[object.id] != "undefined") { 
     632//  } 
     633//  if ( typeof this.btnList[object.id] != "undefined" ) 
     634//  { 
    600635    // alert("WARNING [HTMLArea.Config::registerDropdown]:\nA button with the same ID already exists."); 
    601   } 
     636//  } 
    602637  this.customSelects[object.id] = object; 
    603638}; 
     
    613648 * create a brand new toolbar ;-) 
    614649 */ 
    615 HTMLArea.Config.prototype.hideSomeButtons = function(remove) { 
     650HTMLArea.Config.prototype.hideSomeButtons = function(remove) 
     651{ 
    616652  var toolbar = this.toolbar; 
    617   for (var i = toolbar.length; --i >= 0;) { 
     653  for ( var i = toolbar.length; --i >= 0; ) 
     654  { 
    618655    var line = toolbar[i]; 
    619     for (var j = line.length; --j >= 0; ) { 
    620       if (remove.indexOf(" " + line[j] + " ") >= 0) { 
     656    for ( var j = line.length; --j >= 0; ) 
     657    { 
     658      if ( remove.indexOf(" " + line[j] + " ") >= 0 ) 
     659      { 
    621660        var len = 1; 
    622         if (/separator|space/.test(line[j + 1])) { 
     661        if ( /separator|space/.test(line[j + 1]) ) 
     662        { 
    623663          len = 2; 
    624664        } 
     
    641681*/ 
    642682 
    643 HTMLArea.Config.prototype.addToolbarElement = function(id, where, position) { 
     683HTMLArea.Config.prototype.addToolbarElement = function(id, where, position) 
     684{ 
    644685  var toolbar = this.toolbar; 
    645686  var a, i, j, o, sid; 
     
    652693  var found = false; 
    653694  // check if id and where are arrys 
    654   if ((id && typeof id == "object") && (id.constructor == Array)) { 
     695  if ( ( id && typeof id == "object" ) && ( id.constructor == Array ) ) 
     696  { 
    655697    idIsArray = true; 
    656698  } 
    657   if ((where && typeof where == "object") && (where.constructor == Array)) { 
     699  if ( ( where && typeof where == "object" ) && ( where.constructor == Array ) ) 
     700  { 
    658701    whereIsArray = true; 
    659702    whereLength = where.length; 
    660703        } 
    661704 
    662   if (idIsArray) { //find the button/select box in input array 
    663     for (i = 0; i < id.length; ++i) { 
    664       if ((id[i] != "separator") && (id[i].indexOf("T[") !== 0)) { 
     705  if ( idIsArray ) //find the button/select box in input array 
     706  { 
     707    for ( i = 0; i < id.length; ++i ) 
     708    { 
     709      if ( ( id[i] != "separator" ) && ( id[i].indexOf("T[") !== 0) ) 
     710      { 
    665711        sid = id[i]; 
    666712      } 
    667713    } 
    668   } else { 
     714  } 
     715  else 
     716  { 
    669717    sid = id; 
    670718  } 
    671719 
    672   for (i = 0; !exists && !found && i < toolbar.length; ++i) { 
     720  for ( i = 0; !exists && !found && i < toolbar.length; ++i ) 
     721  { 
    673722    a = toolbar[i]; 
    674     for (j = 0; !found && j < a.length; ++j) { 
    675       if (a[i] == sid) { // check if button/select box exists 
     723    for ( j = 0; !found && j < a.length; ++j ) 
     724    { 
     725      // check if button/select box exists 
     726      if ( a[i] == sid ) 
     727      {  
    676728        exists = true; 
    677729        break; 
    678730      } 
    679       if (whereIsArray) { 
    680         for (o = 0; o < whereLength; ++o) { 
    681           if(a[j] == where[o]) { 
    682             if (o === 0) { 
     731      if ( whereIsArray ) 
     732      { 
     733        for ( o = 0; o < whereLength; ++o ) 
     734        { 
     735          if ( a[j] == where[o] ) 
     736          { 
     737            if ( o === 0 ) 
     738            { 
    683739              found = true; 
    684740              j--; 
    685741              break; 
    686             } else { 
     742            } 
     743            else 
     744            { 
    687745              whereI = i; 
    688746              whereJ = j; 
     
    691749          } 
    692750        } 
    693       } else { 
    694         if (a[j] == where) { // find the position to insert 
     751      } 
     752      else 
     753      { 
     754        // find the position to insert 
     755        if ( a[j] == where ) 
     756        {  
    695757          found = true; 
    696758          break; 
     
    700762  } 
    701763 
    702   if (!exists) { 
    703     if (!found && whereIsArray) { //if check found any other as the first button 
    704       if (where.length != whereLength) { 
     764  if ( !exists ) 
     765  { 
     766    //if check found any other as the first button 
     767    if ( !found && whereIsArray ) 
     768    {  
     769      if ( where.length != whereLength ) 
     770      { 
    705771        j = whereJ; 
    706772        a = toolbar[whereI]; 
     
    708774      } 
    709775    } 
    710     if (found) { 
    711       if (position === 0) { // replace the found button 
    712         if (idIsArray) { 
     776    if ( found ) 
     777    { 
     778      // replace the found button 
     779      if ( position === 0 ) 
     780      { 
     781        if ( idIsArray) 
     782        { 
    713783          a[j] = id[id.length-1]; 
    714           for (i = id.length-1; --i >= 0;) { 
     784          for ( i = id.length-1; --i >= 0; ) 
     785          { 
    715786            a.splice(j, 0, id[i]); 
    716787          } 
    717         } else { 
     788        } 
     789        else 
     790        { 
    718791          a[j] = id; 
    719792        } 
    720       } else { // insert before/after the found button 
    721         if (position < 0) { 
     793      } 
     794      else 
     795      {  
     796        // insert before/after the found button 
     797        if ( position < 0 ) 
     798        { 
    722799          j = j + position + 1; //correct position before 
    723         } else if (position > 0) { 
     800        } 
     801        else if ( position > 0 ) 
     802        { 
    724803          j = j + position; //correct posion after 
    725804        } 
    726         if (idIsArray) { 
    727           for (i = id.length; --i >= 0;) { 
     805        if ( idIsArray ) 
     806        { 
     807          for ( i = id.length; --i >= 0; ) 
     808          { 
    728809            a.splice(j, 0, id[i]); 
    729810          } 
    730         } else { 
    731            a.splice(j, 0, id); 
    732         } 
    733       } 
    734     }   else { // no button found 
     811        } 
     812        else 
     813        { 
     814          a.splice(j, 0, id); 
     815        } 
     816      } 
     817    } 
     818    else 
     819    { 
     820      // no button found 
    735821      toolbar[0].splice(0, 0, "separator"); 
    736       if (idIsArray) { 
    737         for (i = id.length; --i >= 0;) { 
     822      if ( idIsArray) 
     823      { 
     824        for ( i = id.length; --i >= 0; ) 
     825        { 
    738826          toolbar[0].splice(0, 0, id[i]); 
    739827        } 
    740       } else { 
     828      } 
     829      else 
     830      { 
    741831        toolbar[0].splice(0, 0, id); 
    742832      } 
     
    746836 
    747837/** Helper function: replace all TEXTAREA-s in the document with HTMLArea-s. */ 
    748 HTMLArea.replaceAll = function(config) { 
     838HTMLArea.replaceAll = function(config) 
     839{ 
    749840  var tas = document.getElementsByTagName("textarea"); 
    750841  // @todo: weird syntax, doesnt help to read the code, doesnt obfuscate it and doesnt make it quicker, better rewrite this part 
    751   for (var i = tas.length; i > 0; (new HTMLArea(tas[--i], config)).generate()) 
     842  for ( var i = tas.length; i > 0; (new HTMLArea(tas[--i], config)).generate() ) 
    752843  { 
    753844    // NOP 
     
    763854 
    764855// Creates the toolbar and appends it to the _htmlarea 
    765 HTMLArea.prototype._createToolbar = function () { 
     856HTMLArea.prototype._createToolbar = function () 
     857{ 
    766858  this.setLoadingMessage('Create Toolbar'); 
    767859  var editor = this;    // to access this in nested functions 
     
    787879 
    788880// FIXME : function never used, can probably be removed from source 
    789 HTMLArea.prototype._setConfig = function(config) { 
     881HTMLArea.prototype._setConfig = function(config) 
     882{ 
    790883        this.config = config; 
    791884}; 
    792885 
    793 HTMLArea.prototype._addToolbar = function() { 
     886HTMLArea.prototype._addToolbar = function() 
     887{ 
    794888        this._createToolbar1(this, this._toolbar, this._toolbarObjects); 
    795889}; 
     
    813907 
    814908// separate from previous createToolBar to allow dynamic change of toolbar 
    815 HTMLArea.prototype._createToolbar1 = function (editor, toolbar, tb_objects) { 
     909HTMLArea.prototype._createToolbar1 = function (editor, toolbar, tb_objects) 
     910{ 
    816911  var tb_row; 
    817912  // This shouldn't be necessary, but IE seems to float outside of the container 
    818913  // when we float toolbar sections, so we have to clear:both here as well 
    819914  // as at the end (which we do have to do). 
    820   if(editor.config.flowToolbars) 
     915  if ( editor.config.flowToolbars ) 
    821916  { 
    822917    toolbar.appendChild(HTMLArea._createToolbarBreakingElement()); 
     
    824919 
    825920  // creates a new line in the toolbar 
    826   function newLine() { 
    827     if(typeof tb_row != 'undefined' && tb_row.childNodes.length === 0) { return; } 
     921  function newLine() 
     922  { 
     923    if ( typeof tb_row != 'undefined' && tb_row.childNodes.length === 0) 
     924    { 
     925      return; 
     926    } 
    828927 
    829928    var table = document.createElement("table"); 
     
    831930    table.cellSpacing = "0px"; 
    832931    table.cellPadding = "0px"; 
    833     if(editor.config.flowToolbars) 
    834     { 
    835       if(HTMLArea.is_ie) 
     932    if ( editor.config.flowToolbars ) 
     933    { 
     934      if ( HTMLArea.is_ie ) 
    836935      { 
    837936        table.style.styleFloat = "left"; 
     
    860959  // a toolbar element object (unnamed objects created by createButton or 
    861960  // createSelect functions below). 
    862   function setButtonStatus(id, newval) { 
     961  function setButtonStatus(id, newval) 
     962  { 
    863963    var oldval = this[id]; 
    864964    var el = this.element; 
    865     if (oldval != newval) { 
    866       switch (id) { 
    867           case "enabled": 
    868         if (newval) { 
    869           HTMLArea._removeClass(el, "buttonDisabled"); 
    870           el.disabled = false; 
    871         } else { 
    872           HTMLArea._addClass(el, "buttonDisabled"); 
    873           el.disabled = true; 
    874         } 
     965    if ( oldval != newval ) 
     966    { 
     967      switch (id) 
     968      { 
     969        case "enabled": 
     970          if ( newval ) 
     971          { 
     972            HTMLArea._removeClass(el, "buttonDisabled"); 
     973            el.disabled = false; 
     974          } 
     975          else 
     976          { 
     977            HTMLArea._addClass(el, "buttonDisabled"); 
     978            el.disabled = true; 
     979          } 
    875980        break; 
    876           case "active": 
    877         if (newval) { 
    878           HTMLArea._addClass(el, "buttonPressed"); 
    879         } else { 
    880           HTMLArea._removeClass(el, "buttonPressed"); 
    881         } 
     981        case "active": 
     982          if ( newval ) 
     983          { 
     984            HTMLArea._addClass(el, "buttonPressed"); 
     985          } 
     986          else 
     987          { 
     988            HTMLArea._removeClass(el, "buttonPressed"); 
     989          } 
    882990        break; 
    883991      } 
     
    890998  // This function is called from createButton, above, if the given "txt" 
    891999  // doesn't match a button. 
    892   function createSelect(txt) { 
     1000  function createSelect(txt) 
     1001  { 
    8931002    var options = null; 
    8941003    var el = null; 
     
    8971006    var context = null; 
    8981007    var tooltip = ""; 
    899     switch (txt) { 
    900         case "fontsize": 
    901         case "fontname": 
    902         case "formatblock": 
    903       // the following line retrieves the correct 
    904       // configuration option because the variable name 
    905       // inside the Config object is named the same as the 
    906       // button/select in the toolbar.  For instance, if txt 
    907       // == "formatblock" we retrieve config.formatblock (or 
    908       // a different way to write it in JS is 
    909       // config["formatblock"]. 
    910       options = editor.config[txt]; 
    911       cmd = txt; 
     1008    switch (txt) 
     1009    { 
     1010      case "fontsize": 
     1011      case "fontname": 
     1012      case "formatblock": 
     1013        // the following line retrieves the correct 
     1014        // configuration option because the variable name 
     1015        // inside the Config object is named the same as the 
     1016        // button/select in the toolbar.  For instance, if txt 
     1017        // == "formatblock" we retrieve config.formatblock (or 
     1018        // a different way to write it in JS is 
     1019        // config["formatblock"]. 
     1020        options = editor.config[txt]; 
     1021        cmd = txt; 
    9121022      break; 
    913         default: 
    914       // try to fetch it from the list of registered selects 
    915       cmd = txt; 
    916       var dropdown = customSelects[cmd]; 
    917       if (typeof dropdown != "undefined") { 
    918         options = dropdown.options; 
    919         context = dropdown.context; 
    920         if (typeof dropdown.tooltip != "undefined") { 
    921           tooltip = dropdown.tooltip; 
    922         } 
    923       } else { 
    924         alert("ERROR [createSelect]:\nCan't find the requested dropdown definition"); 
    925       } 
     1023      default: 
     1024        // try to fetch it from the list of registered selects 
     1025        cmd = txt; 
     1026        var dropdown = customSelects[cmd]; 
     1027        if ( typeof dropdown != "undefined" ) 
     1028        { 
     1029          options = dropdown.options; 
     1030          context = dropdown.context; 
     1031          if ( typeof dropdown.tooltip != "undefined" ) 
     1032          { 
     1033            tooltip = dropdown.tooltip; 
     1034          } 
     1035        } 
     1036        else 
     1037        { 
     1038          alert("ERROR [createSelect]:\nCan't find the requested dropdown definition"); 
     1039        } 
    9261040      break; 
    9271041    } 
    928     if (options) { 
     1042    if ( options ) 
     1043    { 
    9291044      el = document.createElement("select"); 
    9301045      el.title = tooltip; 
    931       var obj = { 
     1046      var obj = 
     1047      { 
    9321048        name    : txt, // field name 
    9331049        element : el,   // the UI element (SELECT) 
     
    9431059      tb_objects[txt] = obj; 
    9441060       
    945       for (var i in options) { 
    946         if (typeof(options[i]) != 'string') { continue; }  // prevent iterating over wrong type 
     1061      for ( var i in options ) 
     1062      { 
     1063        // prevent iterating over wrong type 
     1064        if ( typeof(options[i]) != 'string' ) 
     1065        { 
     1066          continue; 
     1067        } 
    9471068        var op = document.createElement("option"); 
    9481069        op.innerHTML = HTMLArea._lc(i); 
     
    9501071        el.appendChild(op); 
    9511072      } 
    952       HTMLArea._addEvent(el, "change", function () { 
    953         editor._comboSelected(el, txt); 
    954       }); 
     1073      HTMLArea._addEvent(el, "change", function () { editor._comboSelected(el, txt); } ); 
    9551074    } 
    9561075    return el; 
     
    9581077 
    9591078  // appends a new button to toolbar 
    960   function createButton(txt) { 
     1079  function createButton(txt) 
     1080  { 
    9611081    // the element that will be created 
    9621082    var el, btn, obj = null; 
    963     switch (txt) { 
    964         case "separator": 
    965           if(editor.config.flowToolbars) { newLine(); } 
    966       el = document.createElement("div"); 
    967       el.className = "separator"; 
     1083    switch (txt) 
     1084    { 
     1085      case "separator": 
     1086        if ( editor.config.flowToolbars ) 
     1087        { 
     1088          newLine(); 
     1089        } 
     1090        el = document.createElement("div"); 
     1091        el.className = "separator"; 
    9681092      break; 
    969         case "space": 
    970       el = document.createElement("div"); 
    971       el.className = "space"; 
     1093      case "space": 
     1094        el = document.createElement("div"); 
     1095        el.className = "space"; 
    9721096      break; 
    9731097      case "linebreak": 
    974           newLine(); 
    975           return false; 
    976         case "textindicator": 
    977       el = document.createElement("div"); 
    978       el.appendChild(document.createTextNode("A")); 
    979       el.className = "indicator"; 
    980       el.title = HTMLArea._lc("Current style"); 
    981       obj = { 
    982         name    : txt, // the button name (i.e. 'bold') 
    983         element : el, // the UI element (DIV) 
    984         enabled : true, // is it enabled? 
    985         active  : false, // is it pressed? 
    986         text    : false, // enabled in text mode? 
    987         cmd     : "textindicator", // the command ID 
    988         state   : setButtonStatus // for changing state 
    989       }; 
     1098        newLine(); 
     1099        return false; 
     1100      case "textindicator": 
     1101        el = document.createElement("div"); 
     1102        el.appendChild(document.createTextNode("A")); 
     1103        el.className = "indicator"; 
     1104        el.title = HTMLArea._lc("Current style"); 
     1105        obj = 
     1106        { 
     1107          name  : txt, // the button name (i.e. 'bold') 
     1108          element : el, // the UI element (DIV) 
     1109          enabled : true, // is it enabled? 
     1110          active        : false, // is it pressed? 
     1111          text  : false, // enabled in text mode? 
     1112          cmd   : "textindicator", // the command ID 
     1113          state : setButtonStatus // for changing state 
     1114        }; 
    9901115       
    991       HTMLArea.freeLater(obj); 
     1116        HTMLArea.freeLater(obj); 
    9921117       
    993       tb_objects[txt] = obj; 
     1118        tb_objects[txt] = obj; 
    9941119      break; 
    995         default: 
    996       btn = editor.config.btnList[txt]; 
    997     } 
    998     if (!el && btn) { 
     1120      default: 
     1121        btn = editor.config.btnList[txt]; 
     1122    } 
     1123    if ( !el && btn ) 
     1124    { 
    9991125      el = document.createElement("a"); 
    10001126      el.style.display = 'block'; 
     
    10051131      // let's just pretend we have a button object, and 
    10061132      // assign all the needed information to it. 
    1007       obj = { 
    1008         name    : txt, // the button name (i.e. 'bold') 
     1133      obj = 
     1134      { 
     1135        name : txt, // the button name (i.e. 'bold') 
    10091136        element : el, // the UI element (DIV) 
    10101137        enabled : true, // is it enabled? 
    1011         active  : false, // is it pressed? 
    1012         text    : btn[2], // enabled in text mode? 
     1138        active : false, // is it pressed? 
     1139        text : btn[2], // enabled in text mode? 
    10131140        cmd     : btn[3], // the command ID 
    10141141        state   : setButtonStatus, // for changing state 
     
    10201147      tb_objects[txt] = obj; 
    10211148      // handlers to emulate nice flat toolbar buttons 
    1022       HTMLArea._addEvent(el, "mouseout", function (ev) 
    1023       { 
    1024         if (obj.enabled) 
    1025         { 
    1026           //HTMLArea._removeClass(el, "buttonHover"); 
    1027           HTMLArea._removeClass(el, "buttonActive"); 
    1028           if (obj.active) { HTMLArea._addClass(el, "buttonPressed"); } 
    1029         } 
    1030       }); 
    1031  
    1032       HTMLArea._addEvent(el, "mousedown", function (ev) 
    1033       { 
    1034         if (obj.enabled) 
    1035         { 
    1036           HTMLArea._addClass(el, "buttonActive"); 
    1037           HTMLArea._removeClass(el, "buttonPressed"); 
    1038           HTMLArea._stopEvent(HTMLArea.is_ie ? window.event : ev); 
    1039         } 
    1040       }); 
     1149      HTMLArea._addEvent( 
     1150        el, 
     1151        "mouseout", 
     1152        function(ev) 
     1153        { 
     1154          if ( obj.enabled ) 
     1155          { 
     1156            //HTMLArea._removeClass(el, "buttonHover"); 
     1157            HTMLArea._removeClass(el, "buttonActive"); 
     1158            if ( obj.active ) 
     1159            { 
     1160              HTMLArea._addClass(el, "buttonPressed"); 
     1161            } 
     1162          } 
     1163        } 
     1164      ); 
     1165 
     1166      HTMLArea._addEvent( 
     1167        el, 
     1168        "mousedown", 
     1169        function(ev) 
     1170        { 
     1171          if ( obj.enabled ) 
     1172          { 
     1173            HTMLArea._addClass(el, "buttonActive"); 
     1174            HTMLArea._removeClass(el, "buttonPressed"); 
     1175            HTMLArea._stopEvent(HTMLArea.is_ie ? window.event : ev); 
     1176          } 
     1177        } 
     1178      ); 
    10411179 
    10421180      // when clicked, do the following: 
    1043       HTMLArea._addEvent(el, "click", function (ev) { 
    1044         if (obj.enabled) 
    1045         { 
    1046           HTMLArea._removeClass(el, "buttonActive"); 
    1047           //HTMLArea._removeClass(el, "buttonHover"); 
    1048           if(HTMLArea.is_gecko) 
     1181      HTMLArea._addEvent( 
     1182        el, 
     1183        "click", 
     1184        function(ev) 
     1185        { 
     1186          if ( obj.enabled ) 
    10491187          { 
    1050             editor.activateEditor(); 
     1188            HTMLArea._removeClass(el, "buttonActive"); 
     1189            //HTMLArea._removeClass(el, "buttonHover"); 
     1190            if ( HTMLArea.is_gecko ) 
     1191            { 
     1192              editor.activateEditor(); 
     1193            } 
     1194            obj.cmd(editor, obj.name, obj); 
     1195            HTMLArea._stopEvent(HTMLArea.is_ie ? window.event : ev); 
    10511196          } 
    1052           obj.cmd(editor, obj.name, obj); 
    1053           HTMLArea._stopEvent(HTMLArea.is_ie ? window.event : ev); 
    1054         } 
    1055       }); 
     1197        } 
     1198      ); 
    10561199 
    10571200      var i_contain = HTMLArea.makeBtnImg(btn[1]); 
     
    10621205      obj.swapImage = function(newimg) 
    10631206      { 
    1064         if(typeof newimg != 'string') 
     1207        if ( typeof newimg != 'string' ) 
    10651208        { 
    10661209          img.src = newimg[0]; 
     
    10771220      }; 
    10781221       
    1079     } else if (!el) { 
     1222    } 
     1223    else if( !el ) 
     1224    { 
    10801225      el = createSelect(txt); 
    10811226    } 
     
    10851230 
    10861231  var first = true; 
    1087   for (var i = 0; i < this.config.toolbar.length; ++i) { 
    1088     if (!first) { 
     1232  for ( var i = 0; i < this.config.toolbar.length; ++i ) 
     1233  { 
     1234    if ( !first ) 
     1235    { 
    10891236      // createButton("linebreak"); 
    1090     } else { 
     1237    } 
     1238    else 
     1239    { 
    10911240      first = false; 
    10921241    } 
    1093     if(this.config.toolbar[i] === null) { this.config.toolbar[i] = ['separator']; } 
     1242    if ( this.config.toolbar[i] === null ) 
     1243    { 
     1244      this.config.toolbar[i] = ['separator']; 
     1245    } 
    10941246    var group = this.config.toolbar[i]; 
    10951247 
    1096     for (var j = 0; j < group.length; ++j) 
     1248    for ( var j = 0; j < group.length; ++j ) 
    10971249    { 
    10981250      var code = group[j]; 
    10991251      var tb_cell; 
    1100       if (/^([IT])\[(.*?)\]/.test(code)) 
     1252      if ( /^([IT])\[(.*?)\]/.test(code) ) 
    11011253      { 
    11021254        // special case, create text label 
    11031255        var l7ed = RegExp.$1 == "I"; // localized? 
    11041256        var label = RegExp.$2; 
    1105         if (l7ed) { 
    1106           label = HTMLArea._lc(label); 
     1257        if ( l7ed ) 
     1258        { 
     1259          label = HTMLArea._lc(label); 
    11071260        } 
    11081261        tb_cell = document.createElement("td"); 
     
    11111264        tb_cell.innerHTML = label; 
    11121265      } 
    1113       else if(typeof code != 'function') 
     1266      else if ( typeof code != 'function' ) 
    11141267      { 
    11151268        var tb_element = createButton(code); 
    1116         if (tb_element) 
     1269        if ( tb_element ) 
    11171270        { 
    11181271          tb_cell = document.createElement("td"); 
     
    11211274          tb_cell.appendChild(tb_element); 
    11221275        } 
    1123         else if (tb_element === null) 
     1276        else if ( tb_element === null ) 
    11241277        { 
    11251278          alert("FIXME: Unknown toolbar item: " + code); 
     
    11291282  } 
    11301283 
    1131   if(editor.config.flowToolbars) 
     1284  if ( editor.config.flowToolbars ) 
    11321285  { 
    11331286    toolbar.appendChild(HTMLArea._createToolbarBreakingElement()); 
     
    11421295HTMLArea.makeBtnImg = function(imgDef, doc) 
    11431296{ 
    1144   if(!doc) { doc = document; } 
    1145  
    1146   if(!doc._htmlareaImgCache) 
    1147   { 
    1148     doc._htmlareaImgCache = { }; 
     1297  if ( !doc ) 
     1298  { 
     1299    doc = document; 
     1300  } 
     1301 
     1302  if ( !doc._htmlareaImgCache ) 
     1303  { 
     1304    doc._htmlareaImgCache = {}; 
    11491305    HTMLArea.freeLater(doc._htmlareaImgCache); 
    11501306  } 
    11511307 
    11521308  var i_contain = null; 
    1153   if(HTMLArea.is_ie && ((!doc.compatMode) || (doc.compatMode && doc.compatMode == "BackCompat"))) 
     1309  if ( HTMLArea.is_ie && ( ( !doc.compatMode ) || ( doc.compatMode && doc.compatMode == "BackCompat" ) ) ) 
    11541310  { 
    11551311    i_contain = doc.createElement('span'); 
     
    11641320  i_contain.style.width = "18px"; 
    11651321  i_contain.style.height = "18px"; 
    1166   i_contain.className    = 'buttonImageContainer'; 
     1322  i_contain.className = 'buttonImageContainer'; 
    11671323 
    11681324  var img = null; 
    1169   if(typeof imgDef == 'string') 
    1170   { 
    1171     if(doc._htmlareaImgCache[imgDef]) 
     1325  if ( typeof imgDef == 'string' ) 
     1326  { 
     1327    if ( doc._htmlareaImgCache[imgDef] ) 
    11721328    { 
    11731329      img = doc._htmlareaImgCache[imgDef].cloneNode(); 
     
    11791335      img.style.width = "18px"; 
    11801336      img.style.height = "18px"; 
    1181       if(use_clone_img) 
     1337      if ( use_clone_img ) 
    11821338      { 
    11831339        doc._htmlareaImgCache[imgDef] = img.cloneNode(); 
     
    11871343  else 
    11881344  { 
    1189     if(doc._htmlareaImgCache[imgDef[0]]) 
     1345    if ( doc._htmlareaImgCache[imgDef[0]] ) 
    11901346    { 
    11911347      img = doc._htmlareaImgCache[imgDef[0]].cloneNode(); 
     
    11961352      img.src = imgDef[0]; 
    11971353      img.style.position = 'relative'; 
    1198       if(use_clone_img) 
     1354      if ( use_clone_img ) 
    11991355      { 
    12001356        doc._htmlareaImgCache[imgDef[0]] = img.cloneNode(); 
    12011357      } 
    12021358    } 
     1359    // @todo: Using 18 dont let us use a theme with its own icon toolbar height 
     1360    //        and width. Probably better to calculate this value 18 
     1361    //        var sizeIcon = img.width / nb_elements_per_image; 
    12031362    img.style.top  = imgDef[2] ? ('-' + (18 * (imgDef[2] + 1)) + 'px') : '-18px'; 
    12041363    img.style.left = imgDef[1] ? ('-' + (18 * (imgDef[1] + 1)) + 'px') : '-18px'; 
     
    12081367}; 
    12091368 
    1210 HTMLArea.prototype._createStatusBar = function() { 
     1369HTMLArea.prototype._createStatusBar = function() 
     1370{ 
    12111371  this.setLoadingMessage('Create StatusBar'); 
    12121372  var statusbar = document.createElement("div"); 
     
    12311391  this._statusBar.appendChild(div); 
    12321392 
    1233   if (!this.config.statusBar) 
     1393  if ( !this.config.statusBar ) 
    12341394  { 
    12351395    // disable it... 
     
    12471407  this.setLoadingMessage('Generate Xinha object'); 
    12481408 
    1249   if(typeof Dialog == 'undefined') 
    1250   { 
     1409  if ( typeof Dialog == 'undefined' ) 
     1410  { 
     1411    // why can't we use the following line instead ? 
     1412//    HTMLArea._loadback(_editor_url + 'dialog.js', this.generate ); 
    12511413    HTMLArea._loadback(_editor_url + 'dialog.js', function() { editor.generate(); } ); 
    12521414    return false; 
    12531415  } 
    12541416 
    1255   if(typeof HTMLArea.Dialog == 'undefined') 
    1256   { 
     1417  if ( typeof HTMLArea.Dialog == 'undefined' ) 
     1418  { 
     1419    // why can't we use the following line instead ? 
     1420//    HTMLArea._loadback(_editor_url + 'inline-dialog.js', this.generate ); 
    12571421    HTMLArea._loadback(_editor_url + 'inline-dialog.js', function() { editor.generate(); } ); 
    12581422    return false; 
    12591423  } 
    12601424 
    1261   if(typeof PopupWin == 'undefined') 
    1262   { 
     1425  if ( typeof PopupWin == 'undefined' ) 
     1426  { 
     1427    // why can't we use the following line instead ? 
     1428//    HTMLArea._loadback(_editor_url + 'ipopupwin.js', this.generate ); 
    12631429    HTMLArea._loadback(_editor_url + 'popupwin.js', function() { editor.generate(); } ); 
    12641430    return false; 
    12651431  } 
    12661432 
    1267   if(_editor_skin !== "") { 
    1268     var found=false; 
     1433  if ( _editor_skin !== "" ) 
     1434  { 
     1435    var found = false; 
    12691436    var head = document.getElementsByTagName("head")[0]; 
    12701437    var links = document.getElementsByTagName("link"); 
    1271     for(i = 0; i<links.length; i++) { 
    1272       if((links[i].rel == "stylesheet")&&(links[i].href == _editor_url + 'skins/' + _editor_skin + '/skin.css')) 
     1438    for(i = 0; i<links.length; i++) 
     1439    { 
     1440      if ( ( links[i].rel == "stylesheet" ) && ( links[i].href == _editor_url + 'skins/' + _editor_skin + '/skin.css' ) ) 
    12731441      { 
    12741442        found = true; 
    12751443      } 
    12761444    } 
    1277     if(!found) { 
     1445    if ( !found ) 
     1446    { 
    12781447      var link = document.createElement("link"); 
    12791448      link.type = "text/css"; 
     
    12851454 
    12861455  //backwards-compatibility: load FullScreen-Plugin if we find a "popupeditor"-button in the toolbar 
     1456  // @todo: remove the backward compatibility in release 2.0 
    12871457  var toolbar = editor.config.toolbar; 
    1288   for (i = toolbar.length; --i >= 0;) { 
    1289     for (var j = toolbar[i].length; --j >= 0; ) { 
    1290       if (toolbar[i][j]=="popupeditor") { 
    1291         if(typeof FullScreen == "undefined") { 
     1458  for ( i = toolbar.length; --i >= 0; ) 
     1459  { 
     1460    for ( var j = toolbar[i].length; --j >= 0; ) 
     1461    { 
     1462      if ( toolbar[i][j]=="popupeditor" ) 
     1463      { 
     1464        if ( typeof FullScreen == "undefined" ) 
     1465        { 
     1466          // why can't we use the following line instead ? 
     1467//          HTMLArea.loadPlugin("FullScreen", this.generate ); 
    12921468          HTMLArea.loadPlugin("FullScreen", function() { editor.generate(); } ); 
    12931469          return false; 
     
    12991475 
    13001476  // If this is gecko, set up the paragraph handling now 
    1301   if (HTMLArea.is_gecko && editor.config.mozParaHandler == 'best') 
    1302   { 
    1303     if(typeof EnterParagraphs == 'undefined') 
    1304     { 
     1477  if ( HTMLArea.is_gecko && editor.config.mozParaHandler == 'best' ) 
     1478  { 
     1479    if ( typeof EnterParagraphs == 'undefined' ) 
     1480    { 
     1481      // why can't we use the following line instead ? 
     1482//      HTMLArea.loadPlugin("EnterParagraphs", this.generate ); 
    13051483      HTMLArea.loadPlugin("EnterParagraphs", function() { editor.generate(); } ); 
    13061484      return false; 
     
    13141492  this._framework = 
    13151493  { 
    1316     'table'     :document.createElement('table'), 
    1317     'tbody'     :document.createElement('tbody'), // IE will not show the table if it doesn't have a tbody! 
    1318     'tb_row'    :document.createElement('tr'), 
    1319     'tb_cell'   :document.createElement('td'), // Toolbar 
    1320  
    1321     'tp_row'   :document.createElement('tr'), 
    1322     'tp_cell'   :this._panels.top.container,   // top panel 
    1323  
    1324     'ler_row'   :document.createElement('tr'), 
    1325     'lp_cell'   :this._panels.left.container,  // left panel 
    1326     'ed_cell'   :document.createElement('td'), // editor 
    1327     'rp_cell'   :this._panels.right.container, // right panel 
    1328  
    1329     'bp_row'    :document.createElement('tr'), 
    1330     'bp_cell'   :this._panels.bottom.container,// bottom panel 
    1331  
    1332     'sb_row'    :document.createElement('tr'), 
    1333     'sb_cell'   :document.createElement('td')  // status bar 
     1494    'table':   document.createElement('table'), 
     1495    'tbody':   document.createElement('tbody'), // IE will not show the table if it doesn't have a tbody! 
     1496    'tb_row'document.createElement('tr'), 
     1497    'tb_cell': document.createElement('td'), // Toolbar 
     1498 
     1499    'tp_row'document.createElement('tr'), 
     1500    'tp_cell': this._panels.top.container,   // top panel 
     1501 
     1502    'ler_row': document.createElement('tr'), 
     1503    'lp_cell': this._panels.left.container,  // left panel 
     1504    'ed_cell': document.createElement('td'), // editor 
     1505    'rp_cell': this._panels.right.container, // right panel 
     1506 
     1507    'bp_row'document.createElement('tr'), 
     1508    'bp_cell': this._panels.bottom.container,// bottom panel 
     1509 
     1510    'sb_row'document.createElement('tr'), 
     1511    'sb_cell': document.createElement('td')  // status bar 
    13341512 
    13351513  }; 
    1336  
    13371514  HTMLArea.freeLater(this._framework); 
    13381515   
    13391516  var fw = this._framework; 
    1340   fw.table.border="0"; 
    1341   fw.table.cellPadding="0"; 
    1342   fw.table.cellSpacing="0"; 
     1517  fw.table.border = "0"; 
     1518  fw.table.cellPadding = "0"; 
     1519  fw.table.cellSpacing = "0"; 
    13431520 
    13441521  fw.tb_row.style.verticalAlign = 'top'; 
     
    13541531  // panels are shown.  It's just here to clarify how the thing 
    13551532  // is put togethor. 
    1356   fw.tb_row.appendChild(fw.tb_cell);  fw.tb_cell.colSpan = 3; 
    1357  
    1358   fw.tp_row.appendChild(fw.tp_cell);  fw.tp_cell.colSpan = 3; 
     1533  fw.tb_row.appendChild(fw.tb_cell); 
     1534  fw.tb_cell.colSpan = 3; 
     1535 
     1536  fw.tp_row.appendChild(fw.tp_cell); 
     1537  fw.tp_cell.colSpan = 3; 
    13591538 
    13601539  fw.ler_row.appendChild(fw.lp_cell); 
     
    13621541  fw.ler_row.appendChild(fw.rp_cell); 
    13631542 
    1364   fw.bp_row.appendChild(fw.bp_cell);  fw.bp_cell.colSpan = 3; 
    1365  
    1366   fw.sb_row.appendChild(fw.sb_cell);  fw.sb_cell.colSpan = 3; 
     1543  fw.bp_row.appendChild(fw.bp_cell); 
     1544  fw.bp_cell.colSpan = 3; 
     1545 
     1546  fw.sb_row.appendChild(fw.sb_cell); 
     1547  fw.sb_cell.colSpan = 3; 
    13671548 
    13681549  // Put the rows in the table body 
     
    14071588 
    14081589  // Set up event listeners for saving the iframe content to the textarea 
    1409   if (textarea.form) 
     1590  if ( textarea.form ) 
    14101591  { 
    14111592    // onsubmit get the HTMLArea content and update original textarea. 
    1412     HTMLArea.prependDom0Event 
    1413     ( 
     1593    HTMLArea.prependDom0Event( 
    14141594      this._textArea.form, 
    14151595      'submit', 
    1416       function() {editor._textArea.value = editor.outwardHtml(editor.getHTML()); return true;} 
     1596      function() 
     1597      { 
     1598        editor._textArea.value = editor.outwardHtml(editor.getHTML()); 
     1599        return true; 
     1600      } 
    14171601    ); 
    14181602 
     
    14201604 
    14211605    // onreset revert the HTMLArea content to the textarea content 
    1422     HTMLArea.prependDom0Event 
    1423     ( 
     1606    HTMLArea.prependDom0Event( 
    14241607      this._textArea.form, 
    14251608      'reset', 
    1426       function() { editor.setHTML(editor.inwardHtml(initialTAContent)); editor.updateToolbar(); return true; } 
     1609      function() 
     1610      { 
     1611        editor.setHTML(editor.inwardHtml(initialTAContent)); 
     1612        editor.updateToolbar(); 
     1613        return true; 
     1614      } 
    14271615    ); 
    14281616  } 
     
    14301618  // add a handler for the "back/forward" case -- on body.unload we save 
    14311619  // the HTML content into the original textarea. 
    1432   HTMLArea.prependDom0Event(window, 'unload', function() {textarea.value = editor.outwardHtml(editor.getHTML()); return true; }); 
     1620  HTMLArea.prependDom0Event( 
     1621    window, 
     1622    'unload', 
     1623    function() 
     1624    { 
     1625      textarea.value = editor.outwardHtml(editor.getHTML()); 
     1626      return true; 
     1627    } 
     1628  ); 
    14331629 
    14341630  // Hide textarea 
     
    14401636  // Add an event to initialize the iframe once loaded. 
    14411637  editor._iframeLoadDone = false; 
    1442   HTMLArea._addEvent 
    1443   ( 
     1638  HTMLArea._addEvent( 
    14441639    this._iframe, 
    14451640    'load', 
    14461641    function(e) 
    14471642    { 
    1448       if(! editor._iframeLoadDone) 
     1643      if ( !editor._iframeLoadDone ) 
    14491644      { 
    14501645        editor._iframeLoadDone = true; 
     
    14571652}; 
    14581653 
    1459  
    1460   /** 
    1461    * Size the editor according to the INITIAL sizing information. 
    1462    * config.width 
    1463    *    The width may be set via three ways 
    1464    *    auto    = the width is inherited from the original textarea 
    1465    *    toolbar = the width is set to be the same size as the toolbar 
    1466    *    <set size> = the width is an explicit size (any CSS measurement, eg 100em should be fine) 
    1467    * 
    1468    * config.height 
    1469    *    auto    = the height is inherited from the original textarea 
    1470    *    <set size> = an explicit size measurement (again, CSS measurements) 
    1471    * 
    1472    * config.sizeIncludesBars 
    1473    *    true    = the tool & status bars will appear inside the width & height confines 
    1474    *    false   = the tool & status bars will appear outside the width & height confines 
    1475    * 
    1476    */ 
    1477  
    1478   HTMLArea.prototype.initSize = function() 
    1479   { 
    1480     this.setLoadingMessage('Init editor size'); 
    1481     var editor = this; 
    1482  
    1483     var width  = null; 
    1484     var height = null; 
    1485     switch(this.config.width) 
    1486     { 
    1487       case 'auto': 
    1488         width = this._initial_ta_size.w; 
    1489       break; 
    1490  
    1491       case 'toolbar': 
    1492         width = this._toolBar.offsetWidth + 'px'; 
    1493       break; 
    1494  
    1495       default : 
    1496         // @todo: check if this is better : 
    1497         // width = (parseInt(this.config.width, 10) == this.config.width)? this.config.width + 'px' : this.config.width; 
    1498         width = /[^0-9]/.test(this.config.width) ? this.config.width : this.config.width + 'px'; 
    1499       break; 
    1500     } 
    1501  
    1502     switch(this.config.height) 
    1503     { 
    1504       case 'auto': 
    1505         height = this._initial_ta_size.h; 
    1506       break; 
    1507  
    1508       default : 
    1509         // @todo: check if this is better : 
    1510         // height = (parseInt(this.config.height, 10) == this.config.height)? this.config.height + 'px' : this.config.height; 
    1511         height = /[^0-9]/.test(this.config.height) ? this.config.height : this.config.height + 'px'; 
    1512       break; 
    1513     } 
    1514  
    1515     this.sizeEditor(width, height, this.config.sizeIncludesBars, this.config.sizeIncludesPanels); 
    1516  
    1517     HTMLArea.addDom0Event(window, 'resize', function(e) { editor.sizeEditor(); }); 
    1518  
    1519     this.notifyOn('panel_change',function(){editor.sizeEditor();}); 
    1520   }; 
    1521  
    1522   /** 
    1523    *  Size the editor to a specific size, or just refresh the size (when window resizes for example) 
    1524    *  @param width optional width (CSS specification) 
    1525    *  @param height optional height (CSS specification) 
    1526    *  @param includingBars optional boolean to indicate if the size should include or exclude tool & status bars 
    1527    */ 
    1528  
    1529   HTMLArea.prototype.sizeEditor = function(width, height, includingBars, includingPanels) 
    1530   { 
    1531  
    1532     // We need to set the iframe & textarea to 100% height so that the htmlarea 
    1533     // isn't "pushed out" when we get it's height, so we can change them later. 
    1534     this._iframe.style.height   = '100%'; 
    1535     this._textArea.style.height = '100%'; 
    1536     this._iframe.style.width    = ''; 
    1537     this._textArea.style.width  = ''; 
    1538  
    1539     if(includingBars !== null)   { this._htmlArea.sizeIncludesToolbars = includingBars;   } 
    1540     if(includingPanels !== null) { this._htmlArea.sizeIncludesPanels   = includingPanels; } 
    1541  
    1542     if(width) 
    1543     { 
    1544       this._htmlArea.style.width = width; 
    1545       if(!this._htmlArea.sizeIncludesPanels) 
    1546       { 
    1547         // Need to add some for l & r panels 
    1548         var rPanel = this._panels.right; 
    1549         if(rPanel.on && rPanel.panels.length && HTMLArea.hasDisplayedChildren(rPanel.div)) 
    1550         { 
    1551           this._htmlArea.style.width = this._htmlArea.offsetWidth + parseInt(this.config.panel_dimensions.right, 10); 
    1552         } 
    1553  
    1554         var lPanel = this._panels.left; 
    1555         if(lPanel.on && lPanel.panels.length && HTMLArea.hasDisplayedChildren(lPanel.div)) 
    1556         { 
    1557           this._htmlArea.style.width = this._htmlArea.offsetWidth + parseInt(this.config.panel_dimensions.left, 10); 
    1558         } 
    1559       } 
    1560     } 
    1561  
    1562     if(height) 
    1563     { 
    1564       this._htmlArea.style.height = height; 
    1565       if(!this._htmlArea.sizeIncludesToolbars) 
    1566       { 
    1567         // Need to add some for toolbars 
    1568         this._htmlArea.style.height = (this._htmlArea.offsetHeight + this._toolbar.offsetHeight + this._statusBar.offsetHeight) + 'px'; 
    1569       } 
    1570  
    1571       if(!this._htmlArea.sizeIncludesPanels) 
    1572       { 
    1573         // Need to add some for t & b panels 
    1574         var tPanel = this._panels.top; 
    1575         if(tPanel.on && tPanel.panels.length && HTMLArea.hasDisplayedChildren(tPanel.div)) 
    1576         { 
    1577           this._htmlArea.style.height = (this._htmlArea.offsetHeight + parseInt(this.config.panel_dimensions.top, 10)) + 'px'; 
    1578         } 
    1579  
    1580         var bPanel = this._panels.bottom; 
    1581         if(bPanel.on && bPanel.panels.length && HTMLArea.hasDisplayedChildren(bPanel.div)) 
    1582         { 
    1583           this._htmlArea.style.height = (this._htmlArea.offsetHeight + parseInt(this.config.panel_dimensions.bottom, 10)) + 'px'; 
    1584         } 
    1585       } 
    1586     } 
    1587  
    1588     // At this point we have this._htmlArea.style.width & this._htmlArea.style.height 
    1589     // which are the size for the OUTER editor area, including toolbars and panels 
    1590     // now we size the INNER area and position stuff in the right places. 
    1591     width  = this._htmlArea.offsetWidth; 
    1592     height = this._htmlArea.offsetHeight; 
    1593  
    1594     // Set colspan for toolbar, and statusbar, rowspan for left & right panels, and insert panels to be displayed 
    1595     // into thier rows 
    1596     var panels = this._panels; 
    1597     var editor = this; 
    1598     var col_span = 1; 
    1599  
    1600     function panel_is_alive(pan) 
    1601     { 
    1602       if(panels[pan].on && panels[pan].panels.length && HTMLArea.hasDisplayedChildren(panels[pan].container)) 
    1603       { 
    1604         panels[pan].container.style.display = ''; 
    1605         return true; 
    1606       } 
    1607  
    1608       // Otherwise make sure it's been removed from the framework 
     1654/** 
     1655 * Size the editor according to the INITIAL sizing information. 
     1656 * config.width 
     1657 *    The width may be set via three ways 
     1658 *    auto    = the width is inherited from the original textarea 
     1659 *    toolbar = the width is set to be the same size as the toolbar 
     1660 *    <set size> = the width is an explicit size (any CSS measurement, eg 100em should be fine) 
     1661 * 
     1662 * config.height 
     1663 *    auto    = the height is inherited from the original textarea 
     1664 *    <set size> = an explicit size measurement (again, CSS measurements) 
     1665 * 
     1666 * config.sizeIncludesBars 
     1667 *    true    = the tool & status bars will appear inside the width & height confines 
     1668 *    false   = the tool & status bars will appear outside the width & height confines 
     1669 * 
     1670 */ 
     1671 
     1672HTMLArea.prototype.initSize = function() 
     1673{ 
     1674  this.setLoadingMessage('Init editor size'); 
     1675  var editor = this; 
     1676  var width = null; 
     1677  var height = null; 
     1678 
     1679  switch ( this.config.width ) 
     1680  { 
     1681    case 'auto': 
     1682      width = this._initial_ta_size.w; 
     1683    break; 
     1684 
     1685    case 'toolbar': 
     1686      width = this._toolBar.offsetWidth + 'px'; 
     1687    break; 
     1688 
     1689    default : 
     1690      // @todo: check if this is better : 
     1691      // width = (parseInt(this.config.width, 10) == this.config.width)? this.config.width + 'px' : this.config.width; 
     1692      width = /[^0-9]/.test(this.config.width) ? this.config.width : this.config.width + 'px'; 
     1693    break; 
     1694  } 
     1695 
     1696  switch ( this.config.height ) 
     1697  { 
     1698    case 'auto': 
     1699      height = this._initial_ta_size.h; 
     1700    break; 
     1701 
     1702    default : 
     1703      // @todo: check if this is better : 
     1704      // height = (parseInt(this.config.height, 10) == this.config.height)? this.config.height + 'px' : this.config.height; 
     1705      height = /[^0-9]/.test(this.config.height) ? this.config.height : this.config.height + 'px'; 
     1706    break; 
     1707  } 
     1708 
     1709  this.sizeEditor(width, height, this.config.sizeIncludesBars, this.config.sizeIncludesPanels); 
     1710 
     1711  // why can't we use the following line instead ? 
     1712//  HTMLArea.addDom0Event(window, 'resize', this.sizeEditor); 
     1713  HTMLArea.addDom0Event(window, 'resize', function(e) { editor.sizeEditor(); }); 
     1714 
     1715  // why can't we use the following line instead ? 
     1716//  this.notifyOn('panel_change',this.sizeEditor); 
     1717  this.notifyOn('panel_change',function() { editor.sizeEditor(); }); 
     1718}; 
     1719 
     1720/** 
     1721 *  Size the editor to a specific size, or just refresh the size (when window resizes for example) 
     1722 *  @param width optional width (CSS specification) 
     1723 *  @param height optional height (CSS specification) 
     1724 *  @param includingBars optional boolean to indicate if the size should include or exclude tool & status bars 
     1725 */ 
     1726HTMLArea.prototype.sizeEditor = function(width, height, includingBars, includingPanels) 
     1727{ 
     1728 
     1729  // We need to set the iframe & textarea to 100% height so that the htmlarea 
     1730  // isn't "pushed out" when we get it's height, so we can change them later. 
     1731  this._iframe.style.height   = '100%'; 
     1732  this._textArea.style.height = '100%'; 
     1733  this._iframe.style.width    = ''; 
     1734  this._textArea.style.width  = ''; 
     1735 
     1736  if ( includingBars !== null ) 
     1737  { 
     1738    this._htmlArea.sizeIncludesToolbars = includingBars; 
     1739  } 
     1740  if ( includingPanels !== null ) 
     1741  { 
     1742    this._htmlArea.sizeIncludesPanels = includingPanels; 
     1743  } 
     1744 
     1745  if ( width ) 
     1746  { 
     1747    this._htmlArea.style.width = width; 
     1748    if ( !this._htmlArea.sizeIncludesPanels ) 
     1749    { 
     1750      // Need to add some for l & r panels 
     1751      var rPanel = this._panels.right; 
     1752      if ( rPanel.on && rPanel.panels.length && HTMLArea.hasDisplayedChildren(rPanel.div) ) 
     1753      { 
     1754        this._htmlArea.style.width = this._htmlArea.offsetWidth + parseInt(this.config.panel_dimensions.right, 10); 
     1755      } 
     1756 
     1757      var lPanel = this._panels.left; 
     1758      if ( lPanel.on && lPanel.panels.length && HTMLArea.hasDisplayedChildren(lPanel.div) ) 
     1759      { 
     1760        this._htmlArea.style.width = this._htmlArea.offsetWidth + parseInt(this.config.panel_dimensions.left, 10); 
     1761      } 
     1762    } 
     1763  } 
     1764 
     1765  if ( height ) 
     1766  { 
     1767    this._htmlArea.style.height = height; 
     1768    if ( !this._htmlArea.sizeIncludesToolbars ) 
     1769    { 
     1770      // Need to add some for toolbars 
     1771      this._htmlArea.style.height = (this._htmlArea.offsetHeight + this._toolbar.offsetHeight + this._statusBar.offsetHeight) + 'px'; 
     1772    } 
     1773 
     1774    if ( !this._htmlArea.sizeIncludesPanels ) 
     1775    { 
     1776      // Need to add some for t & b panels 
     1777      var tPanel = this._panels.top; 
     1778      if ( tPanel.on && tPanel.panels.length && HTMLArea.hasDisplayedChildren(tPanel.div) ) 
     1779      { 
     1780        this._htmlArea.style.height = (this._htmlArea.offsetHeight + parseInt(this.config.panel_dimensions.top, 10)) + 'px'; 
     1781      } 
     1782 
     1783      var bPanel = this._panels.bottom; 
     1784      if ( bPanel.on && bPanel.panels.length && HTMLArea.hasDisplayedChildren(bPanel.div) ) 
     1785      { 
     1786        this._htmlArea.style.height = (this._htmlArea.offsetHeight + parseInt(this.config.panel_dimensions.bottom, 10)) + 'px'; 
     1787      } 
     1788    } 
     1789  } 
     1790 
     1791  // At this point we have this._htmlArea.style.width & this._htmlArea.style.height 
     1792  // which are the size for the OUTER editor area, including toolbars and panels 
     1793  // now we size the INNER area and position stuff in the right places. 
     1794  width  = this._htmlArea.offsetWidth; 
     1795  height = this._htmlArea.offsetHeight; 
     1796 
     1797  // Set colspan for toolbar, and statusbar, rowspan for left & right panels, and insert panels to be displayed 
     1798  // into thier rows 
     1799  var panels = this._panels; 
     1800  var editor = this; 
     1801  var col_span = 1; 
     1802 
     1803  function panel_is_alive(pan) 
     1804  { 
     1805    if ( panels[pan].on && panels[pan].panels.length && HTMLArea.hasDisplayedChildren(panels[pan].container) ) 
     1806    { 
     1807      panels[pan].container.style.display = ''; 
     1808      return true; 
     1809    } 
     1810    // Otherwise make sure it's been removed from the framework 
     1811    else 
     1812    { 
     1813      panels[pan].container.style.display='none'; 
     1814      return false; 
     1815    } 
     1816  } 
     1817 
     1818  if ( panel_is_alive('left') ) 
     1819  { 
     1820    col_span += 1;       
     1821  } 
     1822 
     1823//  if ( panel_is_alive('top') ) 
     1824//  { 
     1825    // NOP 
     1826//  } 
     1827 
     1828  if ( panel_is_alive('right') ) 
     1829  { 
     1830    col_span += 1; 
     1831  } 
     1832 
     1833//  if ( panel_is_alive('bottom') ) 
     1834//  { 
     1835    // NOP 
     1836//  } 
     1837 
     1838  this._framework.tb_cell.colSpan = col_span; 
     1839  this._framework.tp_cell.colSpan = col_span; 
     1840  this._framework.bp_cell.colSpan = col_span; 
     1841  this._framework.sb_cell.colSpan = col_span; 
     1842 
     1843  // Put in the panel rows, top panel goes above editor row 
     1844  if ( !this._framework.tp_row.childNodes.length ) 
     1845  { 
     1846    HTMLArea.removeFromParent(this._framework.tp_row); 
     1847  } 
     1848  else 
     1849  { 
     1850    if ( !HTMLArea.hasParentNode(this._framework.tp_row) ) 
     1851    { 
     1852      this._framework.tbody.insertBefore(this._framework.tp_row, this._framework.ler_row); 
     1853    } 
     1854  } 
     1855 
     1856  // bp goes after the editor 
     1857  if ( !this._framework.bp_row.childNodes.length ) 
     1858  { 
     1859    HTMLArea.removeFromParent(this._framework.bp_row); 
     1860  } 
     1861  else 
     1862  { 
     1863    if ( !HTMLArea.hasParentNode(this._framework.bp_row) ) 
     1864    { 
     1865      this._framework.tbody.insertBefore(this._framework.bp_row, this._framework.ler_row.nextSibling); 
     1866    } 
     1867  } 
     1868 
     1869  // finally if the statusbar is on, insert it 
     1870  if ( !this.config.statusBar ) 
     1871  { 
     1872    HTMLArea.removeFromParent(this._framework.sb_row); 
     1873  } 
     1874  else 
     1875  { 
     1876    if ( !HTMLArea.hasParentNode(this._framework.sb_row) ) 
     1877    { 
     1878      this._framework.table.appendChild(this._framework.sb_row); 
     1879    } 
     1880  } 
     1881 
     1882  // Size and set colspans, link up the framework 
     1883  this._framework.lp_cell.style.width  = this.config.panel_dimensions.left; 
     1884  this._framework.rp_cell.style.width  = this.config.panel_dimensions.right; 
     1885  this._framework.tp_cell.style.height = this.config.panel_dimensions.top; 
     1886  this._framework.bp_cell.style.height = this.config.panel_dimensions.bottom; 
     1887  this._framework.tb_cell.style.height = this._toolBar.offsetHeight + 'px'; 
     1888  this._framework.sb_cell.style.height = this._statusBar.offsetHeight + 'px'; 
     1889 
     1890  var edcellheight = height - this._toolBar.offsetHeight - this._statusBar.offsetHeight; 
     1891  if ( panel_is_alive('top') ) 
     1892  { 
     1893    edcellheight -= parseInt(this.config.panel_dimensions.top, 10); 
     1894  } 
     1895  if ( panel_is_alive('bottom') ) 
     1896  { 
     1897    edcellheight -= parseInt(this.config.panel_dimensions.bottom, 10); 
     1898  } 
     1899  this._iframe.style.height = edcellheight + 'px'; 
     1900 
     1901  var edcellwidth = width; 
     1902  if ( panel_is_alive('left') ) 
     1903  { 
     1904    edcellwidth -= parseInt(this.config.panel_dimensions.left, 10); 
     1905  } 
     1906  if ( panel_is_alive('right') ) 
     1907  { 
     1908    edcellwidth -= parseInt(this.config.panel_dimensions.right, 10); 
     1909  } 
     1910  this._iframe.style.width = edcellwidth + 'px'; 
     1911 
     1912  this._textArea.style.height = this._iframe.style.height; 
     1913  this._textArea.style.width  = this._iframe.style.width; 
     1914 
     1915  this.notifyOf('resize', {width:this._htmlArea.offsetWidth, height:this._htmlArea.offsetHeight}); 
     1916}; 
     1917 
     1918HTMLArea.prototype.addPanel = function(side) 
     1919{ 
     1920  var div = document.createElement('div'); 
     1921  div.side = side; 
     1922  if ( side == 'left' || side == 'right' ) 
     1923  { 
     1924    div.style.width = this.config.panel_dimensions[side]; 
     1925  } 
     1926  HTMLArea.addClasses(div, 'panel'); 
     1927  this._panels[side].panels.push(div); 
     1928  this._panels[side].div.appendChild(div); 
     1929 
     1930  this.notifyOf('panel_change', {'action':'add','panel':div}); 
     1931 
     1932  return div; 
     1933}; 
     1934 
     1935HTMLArea.prototype.removePanel = function(panel) 
     1936{ 
     1937  this._panels[panel.side].div.removeChild(panel); 
     1938  var clean = []; 
     1939  for ( var i = 0; i < this._panels[panel.side].panels.length; i++ ) 
     1940  { 
     1941    if ( this._panels[panel.side].panels[i] != panel ) 
     1942    { 
     1943      clean.push(this._panels[panel.side].panels[i]); 
     1944    } 
     1945  } 
     1946  this._panels[panel.side].panels = clean; 
     1947  this.notifyOf('panel_change', {'action':'remove','panel':panel}); 
     1948}; 
     1949 
     1950HTMLArea.prototype.hidePanel = function(panel) 
     1951{ 
     1952  if ( panel ) 
     1953  { 
     1954    panel.style.display = 'none'; 
     1955    this.notifyOf('panel_change', {'action':'hide','panel':panel}); 
     1956  } 
     1957}; 
     1958 
     1959HTMLArea.prototype.showPanel = function(panel) 
     1960{ 
     1961  if ( panel ) 
     1962  { 
     1963    panel.style.display = ''; 
     1964    this.notifyOf('panel_change', {'action':'show','panel':panel}); 
     1965  } 
     1966}; 
     1967 
     1968HTMLArea.prototype.hidePanels = function(sides) 
     1969{ 
     1970  if ( typeof sides == 'undefined' ) 
     1971  { 
     1972    sides = ['left','right','top','bottom']; 
     1973  } 
     1974 
     1975  var reShow = []; 
     1976  for ( var i = 0; i < sides.length;i++ ) 
     1977  { 
     1978    if ( this._panels[sides[i]].on ) 
     1979    { 
     1980      reShow.push(sides[i]); 
     1981      this._panels[sides[i]].on = false; 
     1982    } 
     1983  } 
     1984  this.notifyOf('panel_change', {'action':'multi_hide','sides':sides}); 
     1985}; 
     1986 
     1987HTMLArea.prototype.showPanels = function(sides) 
     1988{ 
     1989  if ( typeof sides == 'undefined' ) 
     1990  { 
     1991    sides = ['left','right','top','bottom']; 
     1992  } 
     1993 
     1994  var reHide = []; 
     1995  for ( var i = 0; i < sides.length; i++ ) 
     1996  { 
     1997    if ( !this._panels[sides[i]].on ) 
     1998    { 
     1999      reHide.push(sides[i]); 
     2000      this._panels[sides[i]].on = true; 
     2001    } 
     2002  } 
     2003  this.notifyOf('panel_change', {'action':'multi_show','sides':sides}); 
     2004}; 
     2005 
     2006HTMLArea.objectProperties = function(obj) 
     2007{ 
     2008  var props = []; 
     2009  for ( var x in obj ) 
     2010  { 
     2011    props[props.length] = x; 
     2012  } 
     2013  return props; 
     2014}; 
     2015 
     2016/* 
     2017 * EDITOR ACTIVATION NOTES: 
     2018 *  when a page has multiple Xinha editors, ONLY ONE should be activated at any time (this is mostly to 
     2019 *  work around a bug in Mozilla, but also makes some sense).  No editor should be activated or focused 
     2020 *  automatically until at least one editor has been activated through user action (by mouse-clicking in 
     2021 *  the editor). 
     2022 */ 
     2023HTMLArea.prototype.editorIsActivated = function() 
     2024{ 
     2025  try 
     2026  { 
     2027    return HTMLArea.is_gecko? this._doc.designMode == 'on' : this._doc.body.contentEditable; 
     2028  } 
     2029  catch (ex) 
     2030  { 
     2031    return false; 
     2032  } 
     2033}; 
     2034 
     2035HTMLArea._someEditorHasBeenActivated = false; 
     2036HTMLArea._currentlyActiveEditor      = false; 
     2037HTMLArea.prototype.activateEditor = function() 
     2038{ 
     2039  // We only want ONE editor at a time to be active 
     2040  if ( HTMLArea._currentlyActiveEditor ) 
     2041  { 
     2042    if ( HTMLArea._currentlyActiveEditor == this ) 
     2043    { 
     2044      return true; 
     2045    } 
     2046    HTMLArea._currentlyActiveEditor.deactivateEditor(); 
     2047  } 
     2048 
     2049  if ( HTMLArea.is_gecko && this._doc.designMode != 'on' ) 
     2050  { 
     2051    try 
     2052    { 
     2053      // cannot set design mode if no display 
     2054      if ( this._iframe.style.display == 'none' ) 
     2055      { 
     2056        this._iframe.style.display = ''; 
     2057        this._doc.designMode = 'on'; 
     2058        this._iframe.style.display = 'none'; 
     2059      } 
    16092060      else 
    16102061      { 
    1611         panels[pan].container.style.display='none'; 
     2062        this._doc.designMode = 'on'; 
     2063      } 
     2064    } catch (ex) {} 
     2065  } 
     2066  else if ( !HTMLArea.is_gecko && this._doc.body.contentEditable !== true ) 
     2067  { 
     2068    this._doc.body.contentEditable = true; 
     2069  } 
     2070 
     2071  // We need to know that at least one editor on the page has been activated 
     2072  // this is because we will not focus any editor until an editor has been activated 
     2073  HTMLArea._someEditorHasBeenActivated = true; 
     2074  HTMLArea._currentlyActiveEditor      = this; 
     2075 
     2076  var editor = this; 
     2077  this.enableToolbar(); 
     2078}; 
     2079 
     2080HTMLArea.prototype.deactivateEditor = function() 
     2081{ 
     2082  // If the editor isn't active then the user shouldn't use the toolbar 
     2083  this.disableToolbar(); 
     2084 
     2085  if ( HTMLArea.is_gecko && this._doc.designMode != 'off' ) 
     2086  { 
     2087    try 
     2088    { 
     2089      this._doc.designMode = 'off'; 
     2090    } catch (ex) {} 
     2091  } 
     2092  else if ( !HTMLArea.is_gecko && this._doc.body.contentEditable !== false ) 
     2093  { 
     2094    this._doc.body.contentEditable = false; 
     2095  } 
     2096 
     2097  if ( HTMLArea._currentlyActiveEditor != this ) 
     2098  { 
     2099    // We just deactivated an editor that wasn't marked as the currentlyActiveEditor 
     2100 
     2101    return; // I think this should really be an error, there shouldn't be a situation where 
     2102            // an editor is deactivated without first being activated.  but it probably won't 
     2103            // hurt anything. 
     2104  } 
     2105 
     2106  HTMLArea._currentlyActiveEditor = false; 
     2107}; 
     2108 
     2109HTMLArea.prototype.initIframe = function() 
     2110{ 
     2111  this.setLoadingMessage('Init IFrame'); 
     2112  this.disableToolbar(); 
     2113  var doc = null; 
     2114  var editor = this; 
     2115  try 
     2116  { 
     2117    if ( editor._iframe.contentDocument ) 
     2118    { 
     2119      this._doc = editor._iframe.contentDocument;         
     2120    } 
     2121    else 
     2122    { 
     2123      this._doc = editor._iframe.contentWindow.document; 
     2124    } 
     2125    doc = this._doc; 
     2126    // try later 
     2127    if ( !doc ) 
     2128    { 
     2129      if ( HTMLArea.is_gecko ) 
     2130      { 
     2131        setTimeout(function() { editor.initIframe(); }, 50); 
    16122132        return false; 
    16132133      } 
    1614     } 
    1615  
    1616     if(panel_is_alive('left')) 
    1617     { 
    1618       col_span += 1;       
    1619     } 
    1620  
    1621     if(panel_is_alive('top')) 
    1622     { 
    1623       // NOP 
    1624     } 
    1625  
    1626     if(panel_is_alive('right')) 
    1627     { 
    1628       col_span += 1; 
    1629     } 
    1630  
    1631     if(panel_is_alive('bottom')) 
    1632     { 
    1633       // NOP 
    1634     } 
    1635  
    1636     this._framework.tb_cell.colSpan = col_span; 
    1637     this._framework.tp_cell.colSpan = col_span; 
    1638     this._framework.bp_cell.colSpan = col_span; 
    1639     this._framework.sb_cell.colSpan = col_span; 
    1640  
    1641     // Put in the panel rows, top panel goes above editor row 
    1642     if(!this._framework.tp_row.childNodes.length) 
    1643     { 
    1644       HTMLArea.removeFromParent(this._framework.tp_row); 
    1645     } 
    1646     else 
    1647     { 
    1648       if(!HTMLArea.hasParentNode(this._framework.tp_row)) 
    1649       { 
    1650         this._framework.tbody.insertBefore(this._framework.tp_row, this._framework.ler_row); 
    1651       } 
    1652     } 
    1653  
    1654     // bp goes after the editor 
    1655     if(!this._framework.bp_row.childNodes.length) 
    1656     { 
    1657       HTMLArea.removeFromParent(this._framework.bp_row); 
    1658     } 
    1659     else 
    1660     { 
    1661       if(!HTMLArea.hasParentNode(this._framework.bp_row)) 
    1662       { 
    1663         this._framework.tbody.insertBefore(this._framework.bp_row, this._framework.ler_row.nextSibling); 
    1664       } 
    1665     } 
    1666  
    1667     // finally if the statusbar is on, insert it 
    1668     if(!this.config.statusBar) 
    1669     { 
    1670       HTMLArea.removeFromParent(this._framework.sb_row); 
    1671     } 
    1672     else 
    1673     { 
    1674       if(!HTMLArea.hasParentNode(this._framework.sb_row)) 
    1675       { 
    1676         this._framework.table.appendChild(this._framework.sb_row); 
    1677       } 
    1678     } 
    1679  
    1680     // Size and set colspans, link up the framework 
    1681     this._framework.lp_cell.style.width  = this.config.panel_dimensions.left; 
    1682     this._framework.rp_cell.style.width  = this.config.panel_dimensions.right; 
    1683     this._framework.tp_cell.style.height = this.config.panel_dimensions.top; 
    1684     this._framework.bp_cell.style.height = this.config.panel_dimensions.bottom; 
    1685     this._framework.tb_cell.style.height = this._toolBar.offsetHeight   + 'px'; 
    1686     this._framework.sb_cell.style.height = this._statusBar.offsetHeight + 'px'; 
    1687  
    1688     var edcellheight = height - this._toolBar.offsetHeight - this._statusBar.offsetHeight; 
    1689     if(panel_is_alive('top'))    { edcellheight  -= parseInt(this.config.panel_dimensions.top, 10); } 
    1690     if(panel_is_alive('bottom')) { edcellheight  -= parseInt(this.config.panel_dimensions.bottom, 10); } 
    1691     this._iframe.style.height = edcellheight + 'px'; 
    1692  
    1693     var edcellwidth = width; 
    1694     if(panel_is_alive('left'))  { edcellwidth -= parseInt(this.config.panel_dimensions.left, 10); } 
    1695     if(panel_is_alive('right')) { edcellwidth -= parseInt(this.config.panel_dimensions.right, 10); } 
    1696     this._iframe.style.width =  edcellwidth + 'px'; 
    1697  
    1698     this._textArea.style.height = this._iframe.style.height; 
    1699     this._textArea.style.width  = this._iframe.style.width; 
    1700  
    1701     this.notifyOf('resize', {width:this._htmlArea.offsetWidth, height:this._htmlArea.offsetHeight}); 
    1702   }; 
    1703  
    1704   HTMLArea.prototype.addPanel = function(side) 
    1705   { 
    1706     var div = document.createElement('div'); 
    1707     div.side = side; 
    1708     if(side == 'left' || side == 'right') 
    1709     { 
    1710       div.style.width = this.config.panel_dimensions[side]; 
    1711     } 
    1712     HTMLArea.addClasses(div, 'panel'); 
    1713     this._panels[side].panels.push(div); 
    1714     this._panels[side].div.appendChild(div); 
    1715  
    1716     this.notifyOf('panel_change', {'action':'add','panel':div}); 
    1717  
    1718     return div; 
    1719   }; 
    1720  
    1721   HTMLArea.prototype.removePanel = function(panel) 
    1722   { 
    1723     this._panels[panel.side].div.removeChild(panel); 
    1724     var clean = [ ]; 
    1725     for(var i = 0; i < this._panels[panel.side].panels.length; i++) 
    1726     { 
    1727       if(this._panels[panel.side].panels[i] != panel) 
    1728       { 
    1729         clean.push(this._panels[panel.side].panels[i]); 
    1730       } 
    1731     } 
    1732     this._panels[panel.side].panels = clean; 
    1733     this.notifyOf('panel_change', {'action':'remove','panel':panel}); 
    1734   }; 
    1735  
    1736   HTMLArea.prototype.hidePanel = function(panel) 
    1737   { 
    1738     if(panel) 
    1739     { 
    1740       panel.style.display = 'none'; 
    1741       this.notifyOf('panel_change', {'action':'hide','panel':panel}); 
    1742     } 
    1743   }; 
    1744  
    1745   HTMLArea.prototype.showPanel = function(panel) 
    1746   { 
    1747     if(panel) 
    1748     { 
    1749       panel.style.display = ''; 
    1750       this.notifyOf('panel_change', {'action':'show','panel':panel}); 
    1751     } 
    1752   }; 
    1753  
    1754   HTMLArea.prototype.hidePanels = function(sides) 
    1755   { 
    1756     if(typeof sides == 'undefined') 
    1757     { 
    1758       sides = ['left','right','top','bottom']; 
    1759     } 
    1760  
    1761     var reShow = []; 
    1762     for(var i = 0; i < sides.length;i++) 
    1763     { 
    1764       if(this._panels[sides[i]].on) 
    1765       { 
    1766         reShow.push(sides[i]); 
    1767         this._panels[sides[i]].on = false; 
    1768       } 
    1769     } 
    1770     this.notifyOf('panel_change', {'action':'multi_hide','sides':sides}); 
    1771   }; 
    1772  
    1773   HTMLArea.prototype.showPanels = function(sides) 
    1774   { 
    1775     if(typeof sides == 'undefined') 
    1776     { 
    1777       sides = ['left','right','top','bottom']; 
    1778     } 
    1779  
    1780     var reHide = []; 
    1781     for(var i = 0; i < sides.length;i++) 
    1782     { 
    1783       if(!this._panels[sides[i]].on) 
    1784       { 
    1785         reHide.push(sides[i]); 
    1786         this._panels[sides[i]].on = true; 
    1787       } 
    1788     } 
    1789     this.notifyOf('panel_change', {'action':'multi_show','sides':sides}); 
    1790   }; 
    1791  
    1792   HTMLArea.objectProperties = function(obj) 
    1793   { 
    1794     var props = [ ]; 
    1795     for(var x in obj) 
    1796     { 
    1797       props[props.length] = x; 
    1798     } 
    1799     return props; 
    1800   }; 
    1801  
    1802   /* 
    1803    * EDITOR ACTIVATION NOTES: 
    1804    *  when a page has multiple Xinha editors, ONLY ONE should be activated at any time (this is mostly to 
    1805    *  work around a bug in Mozilla, but also makes some sense).  No editor should be activated or focused 
    1806    *  automatically until at least one editor has been activated through user action (by mouse-clicking in 
    1807    *  the editor). 
    1808    */ 
    1809  
    1810   HTMLArea.prototype.editorIsActivated = function() 
    1811   { 
    1812     try 
    1813     { 
    1814       return HTMLArea.is_gecko? this._doc.designMode == 'on' : this._doc.body.contentEditable; 
    1815     } 
    1816     catch (ex) 
    1817     { 
    1818       return false; 
    1819     } 
    1820   }; 
    1821  
    1822   HTMLArea._someEditorHasBeenActivated = false; 
    1823   HTMLArea._currentlyActiveEditor      = false; 
    1824   HTMLArea.prototype.activateEditor = function() 
    1825   { 
    1826     // We only want ONE editor at a time to be active 
    1827     if(HTMLArea._currentlyActiveEditor) 
    1828     { 
    1829       if(HTMLArea._currentlyActiveEditor == this) { return true; } 
    1830       HTMLArea._currentlyActiveEditor.deactivateEditor(); 
    1831     } 
    1832  
    1833     if (HTMLArea.is_gecko && this._doc.designMode != 'on') 
    1834     { 
    1835       try 
    1836       { 
    1837         // cannot set design mode if no display 
    1838         if (this._iframe.style.display == 'none') 
    1839         { 
    1840           this._iframe.style.display = ''; 
    1841           this._doc.designMode = 'on'; 
    1842           this._iframe.style.display = 'none'; 
    1843         } 
    1844         else 
    1845         { 
    1846           this._doc.designMode = 'on'; 
    1847         } 
    1848       } catch (ex) {} 
    1849     } 
    1850     else if(!HTMLArea.is_gecko && this._doc.body.contentEditable !== true) 
    1851     { 
    1852       this._doc.body.contentEditable = true; 
    1853     } 
    1854  
    1855     // We need to know that at least one editor on the page has been activated 
    1856     // this is because we will not focus any editor until an editor has been activated 
    1857     HTMLArea._someEditorHasBeenActivated = true; 
    1858     HTMLArea._currentlyActiveEditor      = this; 
    1859  
    1860     var editor = this; 
    1861     this.enableToolbar(); 
    1862   }; 
    1863  
    1864   HTMLArea.prototype.deactivateEditor = function() 
    1865   { 
    1866     // If the editor isn't active then the user shouldn't use the toolbar 
    1867     this.disableToolbar(); 
    1868  
    1869     if (HTMLArea.is_gecko && this._doc.designMode != 'off') 
    1870     { 
    1871       try {this._doc.designMode = 'off';} catch (e) {} 
    1872     } 
    1873     else if(!HTMLArea.is_gecko && this._doc.body.contentEditable !== false) 
    1874     { 
    1875       this._doc.body.contentEditable = false; 
    1876     } 
    1877  
    1878     if(HTMLArea._currentlyActiveEditor != this) 
    1879     { 
    1880       // We just deactivated an editor that wasn't marked as the currentlyActiveEditor 
    1881  
    1882       return; // I think this should really be an error, there shouldn't be a situation where 
    1883               // an editor is deactivated without first being activated.  but it probably won't 
    1884               // hurt anything. 
    1885     } 
    1886  
    1887     HTMLArea._currentlyActiveEditor = false; 
    1888   }; 
    1889  
    1890   HTMLArea.prototype.initIframe = function() 
    1891   { 
    1892     this.setLoadingMessage('Init IFrame'); 
    1893     this.disableToolbar(); 
    1894     var doc = null; 
    1895     var editor = this; 
    1896     try 
    1897     { 
    1898       if (editor._iframe.contentDocument) 
    1899       { 
    1900         this._doc = editor._iframe.contentDocument;         
    1901       } 
    19022134      else 
    19032135      { 
    1904         this._doc = editor._iframe.contentWindow.document; 
    1905       } 
    1906       doc = this._doc;       
    1907       if (!doc) { // try later 
    1908         if (HTMLArea.is_gecko) { 
    1909           setTimeout(function() { editor.initIframe(); }, 50); 
    1910           return false; 
    1911         } else { 
    1912           alert("ERROR: IFRAME can't be initialized."); 
    1913         } 
    1914       } 
    1915     } 
    1916     catch(e) 
    1917     { // try later 
    1918       setTimeout(function() { editor.initIframe(); }, 50); 
    1919     } 
    1920      
    1921     HTMLArea.freeLater(this, '_doc'); 
    1922      
    1923     doc.open(); 
    1924     var html = ''; 
    1925     if (!editor.config.fullPage) { 
    1926       html = "<html>\n"; 
    1927       html += "<head>\n"; 
    1928       html += "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=" + editor.config.charSet + "\">\n"; 
    1929       if(typeof editor.config.baseHref != 'undefined' && editor.config.baseHref !== null) 
    1930       { 
    1931         html += "<base href=\"" + editor.config.baseHref + "\"/>\n"; 
    1932       } 
    1933       html += "<style title=\"table borders\">" 
    1934            + ".htmtableborders, .htmtableborders td, .htmtableborders th {border : 1px dashed lightgrey ! important;} \n" 
    1935            + "</style>\n"; 
    1936       html += "<style type=\"text/css\">" 
    1937            + "html, body { border: 0px;  background-color: #ffffff; } \n" 
    1938            + "span.macro, span.macro ul, span.macro div, span.macro p {background : #CCCCCC;}\n" 
    1939            + "</style>\n"; 
    1940  
    1941       if(editor.config.pageStyle) 
    1942       { 
    1943         html += "<style type=\"text/css\">\n" + editor.config.pageStyle + "\n</style>"; 
    1944       } 
    1945  
    1946       if(typeof editor.config.pageStyleSheets !== 'undefined') 
    1947       { 
    1948         for(var i = 0; i < editor.config.pageStyleSheets.length; i++) 
    1949         { 
    1950           if(editor.config.pageStyleSheets[i].length > 0) 
    1951           { 
    1952               html += "<link rel=\"stylesheet\" type=\"text/css\" href=\"" + editor.config.pageStyleSheets[i] + "\">"; 
    1953             //html += "<style> @import url('" + editor.config.pageStyleSheets[i] + "'); </style>\n"; 
    1954           } 
    1955         } 
    1956       } 
    1957       html += "</head>\n"; 
    1958       html += "<body>\n"; 
    1959       html +=   editor.inwardHtml(editor._textArea.value); 
    1960       html += "</body>\n"; 
    1961       html += "</html>"; 
    1962     } else { 
    1963       html = editor.inwardHtml(editor._textArea.value); 
    1964       if (html.match(HTMLArea.RE_doctype)) { 
    1965         editor.setDoctype(RegExp.$1); 
    1966         html = html.replace(HTMLArea.RE_doctype, ""); 
    1967       } 
    1968     } 
    1969     doc.write(html); 
    1970     doc.close(); 
    1971  
    1972     this.setEditorEvents(); 
    1973   }; 
     2136        alert("ERROR: IFRAME can't be initialized."); 
     2137      } 
     2138    } 
     2139  } 
     2140  catch(ex) 
     2141  { // try later 
     2142    setTimeout(function() { editor.initIframe(); }, 50); 
     2143  } 
     2144   
     2145  HTMLArea.freeLater(this, '_doc'); 
     2146   
     2147  doc.open(); 
     2148  var html = ''; 
     2149  if ( !editor.config.fullPage ) 
     2150  { 
     2151    html = "<html>\n"; 
     2152    html += "<head>\n"; 
     2153    html += "<meta http-equiv=\"Content-Type\" content=\"text/html; charset=" + editor.config.charSet + "\">\n"; 
     2154    if ( typeof editor.config.baseHref != 'undefined' && editor.config.baseHref !== null ) 
     2155    { 
     2156      html += "<base href=\"" + editor.config.baseHref + "\"/>\n"; 
     2157    } 
     2158    html += "<style title=\"table borders\">"; 
     2159    html += ".htmtableborders, .htmtableborders td, .htmtableborders th {border : 1px dashed lightgrey ! important;} \n"; 
     2160    html += "</style>\n"; 
     2161    html += "<style type=\"text/css\">"; 
     2162    html += "html, body { border: 0px;  background-color: #ffffff; } \n"; 
     2163    html += "span.macro, span.macro ul, span.macro div, span.macro p {background : #CCCCCC;}\n"; 
     2164    html += "</style>\n"; 
     2165 
     2166    if ( editor.config.pageStyle ) 
     2167    { 
     2168      html += "<style type=\"text/css\">\n" + editor.config.pageStyle + "\n</style>"; 
     2169    } 
     2170 
     2171    if ( typeof editor.config.pageStyleSheets !== 'undefined' ) 
     2172    { 
     2173      for ( var i = 0; i < editor.config.pageStyleSheets.length; i++ ) 
     2174      { 
     2175        if ( editor.config.pageStyleSheets[i].length > 0 ) 
     2176        { 
     2177          html += "<link rel=\"stylesheet\" type=\"text/css\" href=\"" + editor.config.pageStyleSheets[i] + "\">"; 
     2178          //html += "<style> @import url('" + editor.config.pageStyleSheets[i] + "'); </style>\n"; 
     2179        } 
     2180      } 
     2181    } 
     2182    html += "</head>\n"; 
     2183    html += "<body>\n"; 
     2184    html +=   editor.inwardHtml(editor._textArea.value); 
     2185    html += "</body>\n"; 
     2186    html += "</html>"; 
     2187  } 
     2188  else 
     2189  { 
     2190    html = editor.inwardHtml(editor._textArea.value); 
     2191    if ( html.match(HTMLArea.RE_doctype) ) 
     2192    { 
     2193      editor.setDoctype(RegExp.$1); 
     2194      html = html.replace(HTMLArea.RE_doctype, ""); 
     2195    } 
     2196  } 
     2197  doc.write(html); 
     2198  doc.close(); 
     2199 
     2200  this.setEditorEvents(); 
     2201}; 
    19742202   
    19752203/** Delay a function until the document is ready for operations.  See ticket:547 */ 
     
    19782206  var editor = this;   
    19792207   
    1980   if(!this._doc.body) 
     2208  if ( !this._doc.body ) 
    19812209  { 
    19822210    setTimeout(function() { editor.whenDocReady(doFunction); }, 50); 
     
    19902218// Switches editor mode; parameter can be "textmode" or "wysiwyg".  If no 
    19912219// parameter was passed this function toggles between modes. 
    1992 HTMLArea.prototype.setMode = function(mode) { 
     2220HTMLArea.prototype.setMode = function(mode) 
     2221{ 
    19932222  var html; 
    1994   if (typeof mode == "undefined") { 
    1995     mode = ((this._editMode == "textmode") ? "wysiwyg" : "textmode"); 
    1996   } 
    1997   switch (mode) { 
     2223  if ( typeof mode == "undefined" ) 
     2224  { 
     2225    mode = this._editMode == "textmode" ? "wysiwyg" : "textmode"; 
     2226  } 
     2227  switch ( mode ) 
     2228  { 
    19982229    case "textmode": 
    19992230      html = this.outwardHtml(this.getHTML()); 
     
    20052236      this._textArea.style.display = ''; 
    20062237 
    2007       if (this.config.statusBar) 
     2238      if ( this.config.statusBar ) 
    20082239      { 
    20092240        this._statusBarTree.style.display = "none"; 
     
    20212252      this._textArea.style.display = "none"; 
    20222253      this.activateEditor(); 
    2023       if (this.config.statusBar) 
     2254      if ( this.config.statusBar ) 
    20242255      { 
    20252256        this._statusBarTree.style.display = ""; 
     
    20362267  this._editMode = mode; 
    20372268 
    2038   for (var i in this.plugins) { 
     2269  for ( var i in this.plugins ) 
     2270  { 
    20392271    var plugin = this.plugins[i].instance; 
    2040     if (plugin && typeof plugin.onMode == "function") { plugin.onMode(mode); } 
    2041   } 
    2042 }; 
    2043  
    2044 HTMLArea.prototype.setFullHTML = function(html) { 
     2272    if ( plugin && typeof plugin.onMode == "function" ) 
     2273    { 
     2274      plugin.onMode(mode); 
     2275    } 
     2276  } 
     2277}; 
     2278 
     2279HTMLArea.prototype.setFullHTML = function(html) 
     2280{ 
    20452281  var save_multiline = RegExp.multiline; 
    20462282  RegExp.multiline = true; 
    2047   if (html.match(HTMLArea.RE_doctype)) { 
     2283  if ( html.match(HTMLArea.RE_doctype) ) 
     2284  { 
    20482285    this.setDoctype(RegExp.$1); 
    20492286    html = html.replace(HTMLArea.RE_doctype, ""); 
    20502287  } 
    20512288  RegExp.multiline = save_multiline; 
    2052   if (!HTMLArea.is_ie) { 
    2053     if (html.match(HTMLArea.RE_head)) 
     2289  if ( !HTMLArea.is_ie ) 
     2290  { 
     2291    if ( html.match(HTMLArea.RE_head) ) 
    20542292    { 
    20552293      this._doc.getElementsByTagName("head")[0].innerHTML = RegExp.$1; 
    20562294    } 
    2057     if (html.match(HTMLArea.RE_body)) 
     2295    if ( html.match(HTMLArea.RE_body) ) 
    20582296    { 
    20592297      this._doc.getElementsByTagName("body")[0].innerHTML = RegExp.$1; 
    20602298    } 
    2061   } else { 
     2299  } 
     2300  else 
     2301  { 
    20622302    var reac = this.editorIsActivated(); 
    2063     if(reac) { this.deactivateEditor(); } 
     2303    if ( reac ) 
     2304    { 
     2305      this.deactivateEditor(); 
     2306    } 
    20642307    var html_re = /<html>((.|\n)*?)<\/html>/i; 
    20652308    html = html.replace(html_re, "$1"); 
     
    20672310    this._doc.write(html); 
    20682311    this._doc.close(); 
    2069     if(reac) { this.activateEditor(); } 
     2312    if ( reac ) 
     2313    { 
     2314      this.activateEditor(); 
     2315    } 
    20702316    this.setEditorEvents(); 
    20712317    return true; 
     
    20732319}; 
    20742320 
    2075 HTMLArea.prototype.setEditorEvents = function() { 
     2321HTMLArea.prototype.setEditorEvents = function() 
     2322{ 
    20762323  var editor=this; 
    20772324  var doc=this._doc; 
    20782325  editor.whenDocReady( 
    2079     function() { 
     2326    function() 
     2327    { 
    20802328      // if we have multiple editors some bug in Mozilla makes some lose editing ability 
    2081       HTMLArea._addEvents 
    2082       ( 
     2329      HTMLArea._addEvents( 
    20832330        doc, 
    20842331        ["mousedown"], 
    2085         function() { editor.activateEditor(); return true; } 
     2332        function() 
     2333        { 
     2334          editor.activateEditor(); 
     2335          return true; 
     2336        } 
    20862337      ); 
    20872338 
    20882339      // intercept some events; for updating the toolbar & keyboard handlers 
    2089       HTMLArea._addEvents 
    2090         (doc, ["keydown", "keypress", "mousedown", "mouseup", "drag"], 
    2091          function (event) { 
    2092            return editor._editorEvent(HTMLArea.is_ie ? editor._iframe.contentWindow.event : event); 
    2093          }); 
     2340      HTMLArea._addEvents( 
     2341        doc, 
     2342        ["keydown", "keypress", "mousedown", "mouseup", "drag"], 
     2343        function (event) 
     2344        { 
     2345          return editor._editorEvent(HTMLArea.is_ie ? editor._iframe.contentWindow.event : event); 
     2346        } 
     2347      ); 
    20942348 
    20952349      // check if any plugins have registered refresh handlers 
    2096       for (var i in editor.plugins) { 
     2350      for ( var i in editor.plugins ) 
     2351      { 
    20972352        var plugin = editor.plugins[i].instance; 
    20982353        HTMLArea.refreshPlugin(plugin); 
     
    21002355 
    21012356      // specific editor initialization 
    2102       if(typeof editor._onGenerate == "function") { 
     2357      if ( typeof editor._onGenerate == "function" ) 
     2358      { 
    21032359        editor._onGenerate(); 
    21042360      } 
     
    21142370// Create the specified plugin and register it with this HTMLArea 
    21152371// return the plugin created to allow refresh when necessary 
    2116 HTMLArea.prototype.registerPlugin = function() { 
     2372HTMLArea.prototype.registerPlugin = function() 
     2373{ 
    21172374  var plugin = arguments[0]; 
    21182375 
    21192376  // @todo : try to avoid the use of eval() 
    21202377  // We can only register plugins that have been succesfully loaded 
    2121   if ( plugin === null 
    2122     || typeof plugin == 'undefined' 
    2123     || (typeof plugin == 'string' && eval('typeof ' + plugin) == 'undefined') 
    2124   ) 
     2378  if ( plugin === null || typeof plugin == 'undefined' || (typeof plugin == 'string' && eval('typeof ' + plugin) == 'undefined') ) 
    21252379  { 
    21262380    return false; 
     
    21282382 
    21292383  var args = []; 
    2130   for (var i = 1; i < arguments.length; ++i) 
     2384  for ( var i = 1; i < arguments.length; ++i ) 
    21312385  { 
    21322386    args.push(arguments[i]); 
     
    21392393// full-screen editor code, in order to initialize plugins with the same 
    21402394// parameters as in the opener window. 
    2141 HTMLArea.prototype.registerPlugin2 = function(plugin, args) { 
     2395HTMLArea.prototype.registerPlugin2 = function(plugin, args) 
     2396{ 
    21422397  // @todo : try to avoid the use of eval() 
    2143   if (typeof plugin == "string") 
     2398  if ( typeof plugin == "string" ) 
    21442399  { 
    21452400    plugin = eval(plugin); 
    21462401  } 
    2147   if (typeof plugin == "undefined") { 
     2402  if ( typeof plugin == "undefined" ) 
     2403  { 
    21482404    /* FIXME: This should never happen. But why does it do? */ 
    21492405    return false; 
    21502406  } 
    21512407  var obj = new plugin(this, args); 
    2152   if (obj) { 
     2408  if ( obj ) 
     2409  { 
    21532410    var clone = {}; 
    21542411    var info = plugin._pluginInfo; 
    2155     for (var i in info) 
     2412    for ( var i in info ) 
    21562413    { 
    21572414      clone[i] = info[i]; 
     
    21612418    this.plugins[plugin._pluginInfo.name] = clone; 
    21622419    return obj; 
    2163   } else { 
     2420  } 
     2421  else 
     2422  { 
    21642423    alert("Can't register plugin " + plugin.toString() + "."); 
    21652424  } 
     
    21692428// language loaded already for HTMLArea.  You better make sure that the plugin 
    21702429// _has_ that language, otherwise shit might happen ;-) 
    2171 HTMLArea.getPluginDir = function(pluginName) { 
     2430HTMLArea.getPluginDir = function(pluginName) 
     2431{ 
    21722432  return _editor_url + "plugins/" + pluginName; 
    21732433}; 
    21742434 
    2175 HTMLArea.loadPlugin = function(pluginName, callback) { 
     2435HTMLArea.loadPlugin = function(pluginName, callback) 
     2436{ 
    21762437  // @todo : try to avoid the use of eval() 
    21772438  // Might already be loaded 
    2178   if(eval('typeof ' + pluginName) != 'undefined') 
    2179   { 
    2180     if(callback) 
     2439  if ( eval('typeof ' + pluginName) != 'undefined' ) 
     2440  { 
     2441    if ( callback ) 
    21812442    { 
    21822443      callback(pluginName); 
     
    21862447 
    21872448  var dir = this.getPluginDir(pluginName); 
    2188   var plugin = pluginName.replace(/([a-z])([A-Z])([a-z])/g, 
    2189           function (str, l1, l2, l3) { 
    2190             return l1 + "-" + l2.toLowerCase() + l3; 
    2191           }).toLowerCase() + ".js"; 
     2449  var plugin = pluginName.replace(/([a-z])([A-Z])([a-z])/g, function (str, l1, l2, l3) { return l1 + "-" + l2.toLowerCase() + l3; }).toLowerCase() + ".js"; 
    21922450  var plugin_file = dir + "/" + plugin; 
    21932451 
    2194   if(callback) 
     2452  if ( callback ) 
    21952453  { 
    21962454    HTMLArea._loadback(plugin_file, function() { callback(pluginName); }); 
     
    22202478}; 
    22212479 
    2222 HTMLArea._pluginLoadStatus = { }; 
     2480HTMLArea._pluginLoadStatus = {}; 
    22232481HTMLArea.loadPlugins = function(plugins, callbackIfNotReady) 
    22242482{ 
     
    22262484  var retVal = true; 
    22272485  var nuPlugins = HTMLArea.cloneObject(plugins); 
    2228   while(nuPlugins.length) 
     2486  while ( nuPlugins.length ) 
    22292487  { 
    22302488    var p = nuPlugins.pop(); 
    2231     if(typeof HTMLArea._pluginLoadStatus[p] == 'undefined') 
     2489    if ( typeof HTMLArea._pluginLoadStatus[p] == 'undefined' ) 
    22322490    { 
    22332491      // Load it 
    22342492      HTMLArea._pluginLoadStatus[p] = 'loading'; 
    22352493      HTMLArea.loadPlugin(p, 
    2236           function(plugin) 
     2494        function(plugin) 
     2495        { 
     2496          // @todo : try to avoid the use of eval() 
     2497          if ( eval('typeof ' + plugin) != 'undefined' ) 
    22372498          { 
    2238             // @todo : try to avoid the use of eval() 
    2239             if(eval('typeof ' + plugin) != 'undefined') 
    2240             { 
    2241               HTMLArea._pluginLoadStatus[plugin] = 'ready'; 
    2242             } 
    2243             else 
    2244             { 
    2245               // Actually, this won't happen, because if the script fails 
    2246               // it will throw an exception preventing the callback from 
    2247               // running.  This will leave it always in the "loading" state 
    2248               // unfortunatly that means we can't fail plugins gracefully 
    2249               // by just skipping them. 
    2250               HTMLArea._pluginLoadStatus[plugin] = 'failed'; 
    2251             } 
     2499            HTMLArea._pluginLoadStatus[plugin] = 'ready'; 
    22522500          } 
     2501          else 
     2502          { 
     2503            // Actually, this won't happen, because if the script fails 
     2504            // it will throw an exception preventing the callback from 
     2505            // running.  This will leave it always in the "loading" state 
     2506            // unfortunatly that means we can't fail plugins gracefully 
     2507            // by just skipping them. 
     2508            HTMLArea._pluginLoadStatus[plugin] = 'failed'; 
     2509          } 
     2510        } 
    22532511      ); 
    22542512      retVal = false; 
     
    22562514    else 
    22572515    { 
    2258       switch(HTMLArea._pluginLoadStatus[p]) 
     2516      // @todo: a simple (if) would not be better than this tortuous (switch) structure ? 
     2517      // if ( HTMLArea._pluginLoadStatus[p] !== 'failed' && HTMLArea._pluginLoadStatus[p] !== 'ready' ) 
     2518      // { 
     2519      //   retVal = false; 
     2520      // } 
     2521      switch ( HTMLArea._pluginLoadStatus[p] ) 
    22592522      { 
    22602523        case 'failed': 
     
    22652528        default       : 
    22662529         retVal = false; 
    2267          break; 
    2268       } 
    2269     } 
    2270   } 
    2271  
    2272   if(retVal) { return true; } // All done, just return 
     2530       break; 
     2531      } 
     2532    } 
     2533  } 
     2534 
     2535  // All done, just return 
     2536  if ( retVal ) 
     2537  { 
     2538    return true; 
     2539  }  
    22732540 
    22742541  // Waiting on plugins to load, return false now and come back a bit later 
    22752542  // if we have to callback 
    2276   if(callbackIfNotReady) 
    2277   { 
    2278     setTimeout(function() { if(HTMLArea.loadPlugins(plugins, callbackIfNotReady)) { callbackIfNotReady(); } }, 150); 
     2543  if ( callbackIfNotReady ) 
     2544  { 
     2545    setTimeout(function() { if ( HTMLArea.loadPlugins(plugins, callbackIfNotReady) ) { callbackIfNotReady(); } }, 150); 
    22792546  } 
    22802547  return retVal; 
     
    22822549 
    22832550// refresh plugin by calling onGenerate or onGenerateOnce method. 
    2284 HTMLArea.refreshPlugin = function(plugin) { 
    2285   if (plugin && typeof plugin.onGenerate == "function") 
     2551HTMLArea.refreshPlugin = function(plugin) 
     2552{ 
     2553  if ( plugin && typeof plugin.onGenerate == "function" ) 
    22862554  { 
    22872555    plugin.onGenerate(); 
    22882556  } 
    2289   if (plugin && typeof plugin.onGenerateOnce == "function") { 
     2557  if ( plugin && typeof plugin.onGenerateOnce == "function" ) 
     2558  { 
    22902559    plugin.onGenerateOnce(); 
    22912560    plugin.onGenerateOnce = null; 
     
    22932562}; 
    22942563 
    2295 HTMLArea.loadStyle = function(style, plugin) { 
     2564HTMLArea.loadStyle = function(style, plugin) 
     2565{ 
    22962566  var url = _editor_url || ''; 
    2297   if (typeof plugin != "undefined") { 
     2567  if ( typeof plugin != "undefined" ) 
     2568  { 
    22982569    url += "plugins/" + plugin + "/"; 
    22992570  } 
    23002571  url += style; 
    2301   if (/^\//.test(style)) 
     2572  // @todo: would not it be better to check the first character instead of a regex ? 
     2573  // if ( typeof style == 'string' && style.charAt(0) == '/' ) 
     2574  // { 
     2575  //   url = style; 
     2576  // } 
     2577  if ( /^\//.test(style) ) 
    23022578  { 
    23032579    url = style; 
     
    23162592 ***************************************************/ 
    23172593 
    2318 HTMLArea.prototype.debugTree = function() { 
     2594HTMLArea.prototype.debugTree = function() 
     2595{ 
    23192596  var ta = document.createElement("textarea"); 
    23202597  ta.style.width = "100%"; 
    23212598  ta.style.height = "20em"; 
    23222599  ta.value = ""; 
    2323   function debug(indent, str) { 
    2324     for (; --indent >= 0;) 
     2600  function debug(indent, str) 
     2601  { 
     2602    for ( ; --indent >= 0; ) 
    23252603    { 
    23262604      ta.value += " "; 
     
    23282606    ta.value += str + "\n"; 
    23292607  } 
    2330   function _dt(root, level) { 
     2608  function _dt(root, level) 
     2609  { 
    23312610    var tag = root.tagName.toLowerCase(), i; 
    23322611    var ns = HTMLArea.is_ie ? root.scopeName : root.prefix; 
    23332612    debug(level, "- " + tag + " [" + ns + "]"); 
    2334     for (i = root.firstChild; i; i = i.nextSibling) 
    2335     { 
    2336       if (i.nodeType == 1) 
     2613    for ( i = root.firstChild; i; i = i.nextSibling ) 
     2614    { 
     2615      if ( i.nodeType == 1 ) 
    23372616      { 
    23382617        _dt(i, level + 2); 
     
    23442623}; 
    23452624 
    2346 HTMLArea.getInnerText = function(el) { 
     2625HTMLArea.getInnerText = function(el) 
     2626{ 
    23472627  var txt = '', i; 
    2348   for (i = el.firstChild; i; i = i.nextSibling) { 
    2349     if (i.nodeType == 3) 
     2628  for ( i = el.firstChild; i; i = i.nextSibling ) 
     2629  { 
     2630    if ( i.nodeType == 3 ) 
    23502631    { 
    23512632      txt += i.data; 
    23522633    } 
    2353     else if (i.nodeType == 1) 
     2634    else if ( i.nodeType == 1 ) 
    23542635    { 
    23552636      txt += HTMLArea.getInnerText(i); 
     
    23592640}; 
    23602641 
    2361 HTMLArea.prototype._wordClean = function() { 
    2362   var 
    2363     editor = this, 
    2364     stats = { 
    2365       empty_tags : 0, 
    2366       mso_class  : 0, 
    2367       mso_style  : 0, 
    2368       mso_xmlel  : 0, 
    2369       orig_len   : this._doc.body.innerHTML.length, 
    2370       T          : (new Date()).getTime() 
    2371     }, 
    2372     stats_txt = { 
    2373       empty_tags : "Empty tags removed: ", 
    2374       mso_class  : "MSO class names removed: ", 
    2375       mso_style  : "MSO inline style removed: ", 
    2376       mso_xmlel  : "MSO XML elements stripped: " 
    2377     }; 
    2378   function showStats() { 
     2642HTMLArea.prototype._wordClean = function() 
     2643{ 
     2644  var editor = this; 
     2645  var stats = 
     2646  { 
     2647    empty_tags : 0, 
     2648    mso_class  : 0, 
     2649    mso_style  : 0, 
     2650    mso_xmlel  : 0, 
     2651    orig_len   : this._doc.body.innerHTML.length, 
     2652    T          : (new Date()).getTime() 
     2653  }; 
     2654  var stats_txt = 
     2655  { 
     2656    empty_tags : "Empty tags removed: ", 
     2657    mso_class  : "MSO class names removed: ", 
     2658    mso_style  : "MSO inline style removed: ", 
     2659    mso_xmlel  : "MSO XML elements stripped: " 
     2660  }; 
     2661 
     2662  function showStats() 
     2663  { 
    23792664    var txt = "HTMLArea word cleaner stats: \n\n"; 
    2380     for (var i in stats) 
    2381     { 
    2382       if (stats_txt[i]) 
     2665    for ( var i in stats ) 
     2666    { 
     2667      if ( stats_txt[i] ) 
    23832668      { 
    23842669        txt += stats_txt[i] + stats[i] + "\n"; 
     
    23902675    alert(txt); 
    23912676  } 
    2392   function clearClass(node) { 
     2677 
     2678  function clearClass(node) 
     2679  { 
    23932680    var newc = node.className.replace(/(^|\s)mso.*?(\s|$)/ig, ' '); 
    2394     if (newc != node.className) { 
     2681    if ( newc != node.className ) 
     2682    { 
    23952683      node.className = newc; 
    2396       if (!(/\S/.test(node.className))) { 
     2684      if ( ! ( /\S/.test(node.className) ) ) 
     2685      { 
    23972686        node.removeAttribute("className"); 
    23982687        ++stats.mso_class; 
     
    24002689    } 
    24012690  } 
    2402   function clearStyle(node) { 
     2691 
     2692  function clearStyle(node) 
     2693  { 
    24032694    var declarations = node.style.cssText.split(/\s*;\s*/); 
    2404     for (var i = declarations.length; --i >= 0;) 
    2405     { 
    2406       if ((/^mso|^tab-stops/i.test(declarations[i])) || 
    2407           (/^margin\s*:\s*0..\s+0..\s+0../i.test(declarations[i]))) 
     2695    for ( var i = declarations.length; --i >= 0; ) 
     2696    { 
     2697      if ( ( /^mso|^tab-stops/i.test(declarations[i]) ) || ( /^margin\s*:\s*0..\s+0..\s+0../i.test(declarations[i]) ) ) 
    24082698      { 
    24092699        ++stats.mso_style; 
     
    24132703    node.style.cssText = declarations.join("; "); 
    24142704  } 
     2705 
    24152706  var stripTag = null; 
    2416   if (HTMLArea.is_ie) 
     2707  if ( HTMLArea.is_ie ) 
    24172708  { 
    24182709    stripTag = function(el) 
     
    24322723    }; 
    24332724  } 
    2434   function checkEmpty(el) { 
     2725 
     2726  function checkEmpty(el) 
     2727  { 
    24352728    // @todo : check if this is quicker 
    24362729    //  if (!['A','SPAN','B','STRONG','I','EM','FONT'].contains(el.tagName) && !el.firstChild) 
    2437     if (/^(a|span|b|strong|i|em|font)$/i.test(el.tagName) && 
    2438         !el.firstChild) { 
     2730    if ( /^(a|span|b|strong|i|em|font)$/i.test(el.tagName) && !el.firstChild) 
     2731    { 
    24392732      HTMLArea.removeFromParent(el); 
    24402733      ++stats.empty_tags; 
    24412734    } 
    24422735  } 
    2443   function parseTree(root) { 
     2736 
     2737  function parseTree(root) 
     2738  { 
    24442739    var tag = root.tagName.toLowerCase(), i, next; 
    24452740    // @todo : probably better to use String.indexOf() instead of this ugly regex 
    24462741    // if ((HTMLArea.is_ie && root.scopeName != 'HTML') || (!HTMLArea.is_ie && tag.indexOf(':') !== -1)) { 
    2447     if ((HTMLArea.is_ie && root.scopeName != 'HTML') || (!HTMLArea.is_ie && (/:/.test(tag)))) { 
     2742    if ( ( HTMLArea.is_ie && root.scopeName != 'HTML' ) || ( !HTMLArea.is_ie && ( /:/.test(tag) ) ) ) 
     2743    { 
    24482744      stripTag(root); 
    24492745      return false; 
    2450     } else { 
     2746    } 
     2747    else 
     2748    { 
    24512749      clearClass(root); 
    24522750      clearStyle(root); 
    2453       for (i = root.firstChild; i; i = next) { 
     2751      for ( i = root.firstChild; i; i = next ) 
     2752      { 
    24542753        next = i.nextSibling; 
    2455         if (i.nodeType == 1 && parseTree(i)) 
     2754        if ( i.nodeType == 1 && parseTree(i) ) 
    24562755        { 
    24572756          checkEmpty(i); 
     
    24702769}; 
    24712770 
    2472 HTMLArea.prototype._clearFonts = function() { 
     2771HTMLArea.prototype._clearFonts = function() 
     2772{ 
    24732773  var D = this.getInnerHTML(); 
    24742774 
    2475   if(confirm(HTMLArea._lc("Would you like to clear font typefaces?"))) 
     2775  if ( confirm(HTMLArea._lc("Would you like to clear font typefaces?")) ) 
    24762776  { 
    24772777    D = D.replace(/face="[^"]*"/gi, ''); 
     
    24792779  } 
    24802780 
    2481   if(confirm(HTMLArea._lc("Would you like to clear font sizes?"))) 
     2781  if ( confirm(HTMLArea._lc("Would you like to clear font sizes?")) ) 
    24822782  { 
    24832783    D = D.replace(/size="[^"]*"/gi, ''); 
     
    24852785  } 
    24862786 
    2487   if(confirm(HTMLArea._lc("Would you like to clear font colours?"))) 
     2787  if ( confirm(HTMLArea._lc("Would you like to clear font colours?")) ) 
    24882788  { 
    24892789    D = D.replace(/color="[^"]*"/gi, ''); 
     
    25022802}; 
    25032803 
    2504 HTMLArea.prototype.forceRedraw = function() { 
     2804HTMLArea.prototype.forceRedraw = function() 
     2805{ 
    25052806  this._doc.body.style.visibility = "hidden"; 
    25062807  this._doc.body.style.visibility = "visible"; 
     
    25092810 
    25102811// focuses the iframe window.  returns a reference to the editor document. 
    2511 HTMLArea.prototype.focusEditor = function() { 
    2512   switch (this._editMode) { 
    2513       // notice the try { ... } catch block to avoid some rare exceptions in FireFox 
    2514       // (perhaps also in other Gecko browsers). Manual focus by user is required in 
    2515         // case of an error. Somebody has an idea? 
    2516       case "wysiwyg" : 
     2812HTMLArea.prototype.focusEditor = function() 
     2813{ 
     2814  switch (this._editMode) 
     2815  { 
     2816    // notice the try { ... } catch block to avoid some rare exceptions in FireFox 
     2817    // (perhaps also in other Gecko browsers). Manual focus by user is required in 
     2818    // case of an error. Somebody has an idea? 
     2819    case "wysiwyg" : 
    25172820      try 
    25182821      { 
    25192822        // We don't want to focus the field unless at least one field has been activated. 
    2520         if(HTMLArea._someEditorHasBeenActivated) 
     2823        if ( HTMLArea._someEditorHasBeenActivated ) 
    25212824        { 
    25222825          this.activateEditor(); // Ensure *this* editor is activated 
    25232826          this._iframe.contentWindow.focus(); // and focus it 
    25242827        } 
    2525       } catch (e) {} break; 
    2526       case "textmode": try { this._textArea.focus(); } catch (e) {} break; 
    2527       default      : alert("ERROR: mode " + this._editMode + " is not defined"); 
     2828      } catch (ex) {} 
     2829    break; 
     2830    case "textmode": 
     2831      try 
     2832      { 
     2833        this._textArea.focus(); 
     2834      } catch (e) {} 
     2835    break; 
     2836    default: 
     2837      alert("ERROR: mode " + this._editMode + " is not defined"); 
    25282838  } 
    25292839  return this._doc; 
     
    25312841 
    25322842// takes a snapshot of the current text (for undo) 
    2533 HTMLArea.prototype._undoTakeSnapshot = function() { 
     2843HTMLArea.prototype._undoTakeSnapshot = function() 
     2844{ 
    25342845  ++this._undoPos; 
    2535   if (this._undoPos >= this.config.undoSteps) { 
     2846  if ( this._undoPos >= this.config.undoSteps ) 
     2847  { 
    25362848    // remove the first element 
    25372849    this._undoQueue.shift(); 
     
    25412853  var take = true; 
    25422854  var txt = this.getInnerHTML(); 
    2543   if (this._undoPos > 0) 
     2855  if ( this._undoPos > 0 ) 
    25442856  { 
    25452857    take = (this._undoQueue[this._undoPos - 1] != txt); 
    25462858  } 
    2547   if (take) { 
     2859  if ( take ) 
     2860  { 
    25482861    this._undoQueue[this._undoPos] = txt; 
    2549   } else { 
     2862  } 
     2863  else 
     2864  { 
    25502865    this._undoPos--; 
    25512866  } 
    25522867}; 
    25532868 
    2554 HTMLArea.prototype.undo = function() { 
    2555   if (this._undoPos > 0) { 
     2869HTMLArea.prototype.undo = function() 
     2870{ 
     2871  if ( this._undoPos > 0 ) 
     2872  { 
    25562873    var txt = this._undoQueue[--this._undoPos]; 
    2557     if (txt) { this.setHTML(txt); } 
    2558     else { ++this._undoPos; } 
    2559   } 
    2560 }; 
    2561  
    2562 HTMLArea.prototype.redo = function() { 
    2563   if (this._undoPos < this._undoQueue.length - 1) { 
     2874    if ( txt ) 
     2875    { 
     2876      this.setHTML(txt); 
     2877    } 
     2878    else 
     2879    { 
     2880      ++this._undoPos; 
     2881    } 
     2882  } 
     2883}; 
     2884 
     2885HTMLArea.prototype.redo = function() 
     2886{ 
     2887  if ( this._undoPos < this._undoQueue.length - 1 ) 
     2888  { 
    25642889    var txt = this._undoQueue[++this._undoPos]; 
    2565     if (txt) { this.setHTML(txt); } 
    2566     else { --this._undoPos; } 
     2890    if ( txt ) 
     2891    { 
     2892      this.setHTML(txt); 
     2893    } 
     2894    else 
     2895    { 
     2896      --this._undoPos; 
     2897    } 
    25672898  } 
    25682899}; 
     
    25702901HTMLArea.prototype.disableToolbar = function(except) 
    25712902{ 
    2572   if(this._timerToolbar) { clearTimeout(this._timerToolbar); } 
    2573   if(typeof except == 'undefined') 
     2903  if ( this._timerToolbar ) 
     2904  { 
     2905    clearTimeout(this._timerToolbar); 
     2906  } 
     2907  if ( typeof except == 'undefined' ) 
    25742908  { 
    25752909    except = [ ]; 
    25762910  } 
    2577   else if(typeof except != 'object') 
     2911  else if ( typeof except != 'object' ) 
    25782912  { 
    25792913    except = [except]; 
    25802914  } 
    25812915 
    2582   for (var i in this._toolbarObjects) 
     2916  for ( var i in this._toolbarObjects ) 
    25832917  { 
    25842918    var btn = this._toolbarObjects[i]; 
    2585     if(except.contains(i)) 
     2919    if ( except.contains(i) ) 
    25862920    { 
    25872921      continue; 
    25882922    } 
    2589     if (typeof(btn.state) != 'function') { continue; }  // prevent iterating over wrong type 
     2923    // prevent iterating over wrong type 
     2924    if ( typeof(btn.state) != 'function' ) 
     2925    { 
     2926      continue; 
     2927    } 
    25902928    btn.state("enabled", false); 
    25912929  } 
     
    25972935}; 
    25982936 
    2599 if(!Array.prototype.contains) 
     2937if ( !Array.prototype.contains ) 
    26002938{ 
    26012939  Array.prototype.contains = function(needle) 
    26022940  { 
    2603    var haystack = this; 
    2604    for(var i = 0; i < haystack.length; i++) 
    2605     { 
    2606       if(needle == haystack[i]) { return true; } 
    2607     } 
    2608  
     2941    var haystack = this; 
     2942    for ( var i = 0; i < haystack.length; i++ ) 
     2943    { 
     2944      if ( needle == haystack[i] ) 
     2945      { 
     2946        return true; 
     2947      } 
     2948    } 
    26092949    return false; 
    26102950  }; 
    26112951} 
    26122952 
    2613 if(!Array.prototype.indexOf) 
     2953if ( !Array.prototype.indexOf ) 
    26142954{ 
    26152955  Array.prototype.indexOf = function(needle) 
    26162956  { 
    26172957    var haystack = this; 
    2618     for(var i = 0; i < haystack.length; i++) 
    2619     { 
    2620       if(needle == haystack[i]) { return i; } 
    2621     } 
    2622  
     2958    for ( var i = 0; i < haystack.length; i++ ) 
     2959    { 
     2960      if ( needle == haystack[i] ) 
     2961      { 
     2962        return i; 
     2963      } 
     2964    } 
    26232965    return null; 
    26242966  }; 
     
    26282970// It is actually to heavy to be understable and very scary to manipulate 
    26292971// updates enabled/disable/active state of the toolbar elements 
    2630 HTMLArea.prototype.updateToolbar = function(noStatus) { 
     2972HTMLArea.prototype.updateToolbar = function(noStatus) 
     2973{ 
    26312974  var doc = this._doc; 
    26322975  var text = (this._editMode == "textmode"); 
    26332976  var ancestors = null; 
    2634   if (!text) { 
     2977  if ( !text ) 
     2978  { 
    26352979    ancestors = this.getAllAncestors(); 
    2636     if (this.config.statusBar && !noStatus) { 
     2980    if ( this.config.statusBar && !noStatus ) 
     2981    { 
    26372982      this._statusBarTree.innerHTML = HTMLArea._lc("Path") + ": "; // clear 
    2638       for (var i = ancestors.length; --i >= 0;) { 
     2983      for ( var i = ancestors.length; --i >= 0; ) 
     2984      { 
    26392985        var el = ancestors[i]; 
    2640         if (!el) { 
     2986        if ( !el ) 
     2987        { 
    26412988          // hell knows why we get here; this 
    26422989          // could be a classic example of why 
     
    26492996        a.el = el; 
    26502997        a.editor = this; 
    2651         HTMLArea.addDom0Event(a, 'click', function() { 
    2652           this.blur(); 
    2653           this.editor.selectNodeContents(this.el); 
    2654           this.editor.updateToolbar(true); 
    2655           return false; 
    2656         }); 
    2657         HTMLArea.addDom0Event(a, 'contextmenu',  function() { 
    2658           // TODO: add context menu here 
    2659           this.blur(); 
    2660           var info = "Inline style:\n\n"; 
    2661           info += this.el.style.cssText.split(/;\s*/).join(";\n"); 
    2662           alert(info); 
    2663           return false; 
    2664         }); 
     2998        HTMLArea.addDom0Event( 
     2999          a, 
     3000          'click', 
     3001          function() { 
     3002            this.blur(); 
     3003            this.editor.selectNodeContents(this.el); 
     3004            this.editor.updateToolbar(true); 
     3005            return false; 
     3006          } 
     3007        ); 
     3008        HTMLArea.addDom0Event( 
     3009          a, 
     3010          'contextmenu', 
     3011          function() 
     3012          { 
     3013            // TODO: add context menu here 
     3014            this.blur(); 
     3015            var info = "Inline style:\n\n"; 
     3016            info += this.el.style.cssText.split(/;\s*/).join(";\n"); 
     3017            alert(info); 
     3018            return false; 
     3019          } 
     3020        ); 
    26653021        var txt = el.tagName.toLowerCase(); 
    26663022        a.title = el.style.cssText; 
    2667         if (el.id) { 
     3023        if ( el.id ) 
     3024        { 
    26683025          txt += "#" + el.id; 
    26693026        } 
    2670         if (el.className) { 
     3027        if ( el.className ) 
     3028        { 
    26713029          txt += "." + el.className; 
    26723030        } 
    26733031        a.appendChild(document.createTextNode(txt)); 
    26743032        this._statusBarTree.appendChild(a); 
    2675         if (i !== 0) { 
     3033        if ( i !== 0 ) 
     3034        { 
    26763035          this._statusBarTree.appendChild(document.createTextNode(String.fromCharCode(0xbb))); 
    26773036        } 
     
    26803039  } 
    26813040 
    2682   for (var cmd in this._toolbarObjects) { 
     3041  for ( var cmd in this._toolbarObjects ) 
     3042  { 
    26833043    var btn = this._toolbarObjects[cmd]; 
    26843044    var inContext = true; 
    2685     if (typeof(btn.state) != 'function') { continue; }  // prevent iterating over wrong type 
    2686     if (btn.context && !text) { 
     3045    // prevent iterating over wrong type 
     3046    if ( typeof(btn.state) != 'function' ) 
     3047    { 
     3048      continue; 
     3049    } 
     3050    if ( btn.context && !text ) 
     3051    { 
    26873052      inContext = false; 
    26883053      var context = btn.context; 
    26893054      var attrs = []; 
    2690       if (/(.*)\[(.*?)\]/.test(context)) { 
     3055      if ( /(.*)\[(.*?)\]/.test(context) ) 
     3056      { 
    26913057        context = RegExp.$1; 
    26923058        attrs = RegExp.$2.split(","); 
     
    26943060      context = context.toLowerCase(); 
    26953061      var match = (context == "*"); 
    2696       for (var k = 0; k < ancestors.length; ++k) { 
    2697         if (!ancestors[k]) { 
     3062      for ( var k = 0; k < ancestors.length; ++k ) 
     3063      { 
     3064        if ( !ancestors[k] ) 
     3065        { 
    26983066          // the impossible really happens. 
    26993067          continue; 
    27003068        } 
    2701         if (match || (ancestors[k].tagName.toLowerCase() == context)) { 
     3069        if ( match || ( ancestors[k].tagName.toLowerCase() == context ) ) 
     3070        { 
    27023071          inContext = true; 
    2703           for (var ka = 0; ka < attrs.length; ++ka) { 
    2704             if (!eval("ancestors[k]." + attrs[ka])) { 
     3072          for ( var ka = 0; ka < attrs.length; ++ka ) 
     3073          { 
     3074            if ( !eval("ancestors[k]." + attrs[ka]) ) 
     3075            { 
    27053076              inContext = false; 
    27063077              break; 
    27073078            } 
    27083079          } 
    2709           if (inContext) { 
     3080          if ( inContext ) 
     3081          { 
    27103082            break; 
    27113083          } 
     
    27143086    } 
    27153087    btn.state("enabled", (!text || btn.text) && inContext); 
    2716     if (typeof cmd == "function") { 
     3088    if ( typeof cmd == "function" ) 
     3089    { 
    27173090      continue; 
    27183091    } 
    27193092    // look-it-up in the custom dropdown boxes 
    27203093    var dropdown = this.config.customSelects[cmd]; 
    2721     if ((!text || btn.text) && (typeof dropdown != "undefined")) { 
     3094    if ( ( !text || btn.text ) && ( typeof dropdown != "undefined" ) ) 
     3095    { 
    27223096      dropdown.refresh(this); 
    27233097      continue; 
     
    27273101      case "fontname": 
    27283102      case "fontsize": 
    2729         if (!text) 
     3103        if ( !text ) 
    27303104        { 
    27313105          try 
    27323106          { 
    27333107            var value = ("" + doc.queryCommandValue(cmd)).toLowerCase(); 
    2734             if (!value) 
     3108            if ( !value ) 
    27353109            { 
    27363110              btn.element.selectedIndex = 0; 
     
    27443118            var options = this.config[cmd]; 
    27453119            var sIndex = 0; 
    2746             for (var j in options) 
     3120            for ( var j in options ) 
    27473121            { 
    27483122            // FIXME: the following line is scary. 
    2749               if ((j.toLowerCase() == value) || (options[j].substr(0, value.length).toLowerCase() == value)) 
     3123              if ( ( j.toLowerCase() == value ) || ( options[j].substr(0, value.length).toLowerCase() == value ) ) 
    27503124              { 
    27513125                btn.element.selectedIndex = sIndex; 
     
    27653139      case "formatblock": 
    27663140        var blocks = []; 
    2767         for(var indexBlock in this.config.formatblock) 
    2768         { 
    2769           if (typeof(this.config.formatblock[indexBlock]) == 'string')  // prevent iterating over wrong type 
     3141        for ( var indexBlock in this.config.formatblock ) 
     3142        { 
     3143          // prevent iterating over wrong type 
     3144          if ( typeof this.config.formatblock[indexBlock] == 'string' ) 
    27703145          { 
    27713146            blocks[blocks.length] = this.config.formatblock[indexBlock]; 
     
    27743149 
    27753150        var deepestAncestor = this._getFirstAncestor(this._getSelection(), blocks); 
    2776         if(deepestAncestor) 
    2777         { 
    2778           for(var x = 0; x < blocks.length; x++) 
     3151        if ( deepestAncestor ) 
     3152        { 
     3153          for ( var x = 0; x < blocks.length; x++ ) 
    27793154          { 
    2780             if(blocks[x].toLowerCase() == deepestAncestor.tagName.toLowerCase()) 
     3155            if ( blocks[x].toLowerCase() == deepestAncestor.tagName.toLowerCase() ) 
    27813156            { 
    27823157              btn.element.selectedIndex = x; 
     
    27913166 
    27923167      case "textindicator": 
    2793         if (!text) 
     3168        if ( !text ) 
    27943169        { 
    27953170          try 
     
    27973172            var style = btn.element.style; 
    27983173            style.backgroundColor = HTMLArea._makeColor(doc.queryCommandValue(HTMLArea.is_ie ? "backcolor" : "hilitecolor")); 
    2799             if (/transparent/i.test(style.backgroundColor)) 
     3174            if ( /transparent/i.test(style.backgroundColor) ) 
    28003175            { 
    28013176              // Mozilla 
     
    28063181            style.fontWeight = doc.queryCommandState("bold") ? "bold" : "normal"; 
    28073182            style.fontStyle = doc.queryCommandState("italic") ? "italic" : "normal"; 
    2808           } catch (e) { 
     3183          } catch (ex) { 
    28093184            // alert(e + "\n\n" + cmd); 
    28103185          } 
     
    28193194      case "righttoleft": 
    28203195        var eltBlock = this.getParentElement(); 
    2821         while (eltBlock && !HTMLArea.isBlockElement(eltBlock)) 
     3196        while ( eltBlock && !HTMLArea.isBlockElement(eltBlock) ) 
    28223197        { 
    28233198          eltBlock = eltBlock.parentNode; 
    28243199        } 
    2825         if (eltBlock) 
     3200        if ( eltBlock ) 
    28263201        { 
    28273202          btn.state("active", (eltBlock.style.direction == ((cmd == "righttoleft") ? "rtl" : "ltr"))); 
     
    28313206      default: 
    28323207        cmd = cmd.replace(/(un)?orderedlist/i, "insert$1orderedlist"); 
    2833         try { 
     3208        try 
     3209        { 
    28343210          btn.state("active", (!text && doc.queryCommandState(cmd))); 
    2835         } catch (e) {} 
     3211        } catch (ex) {} 
    28363212      break; 
    28373213    } 
    28383214  } 
    28393215  // take undo snapshots 
    2840   if (this._customUndo && !this._timerUndo) { 
     3216  if ( this._customUndo && !this._timerUndo ) 
     3217  { 
    28413218    this._undoTakeSnapshot(); 
    28423219    var editor = this; 
    2843     this._timerUndo = setTimeout(function() { 
    2844       editor._timerUndo = null; 
    2845     }, this.config.undoTimeout); 
     3220    this._timerUndo = setTimeout(function() { editor._timerUndo = null; }, this.config.undoTimeout); 
    28463221  } 
    28473222 
     
    28543229  //  might solve the problem, whatever the hell it was.  I'm going senile, I'm sure. 
    28553230  // @todo : since this part is disabled since a long time, does it still need to be in the source ? 
    2856   if(0 && HTMLArea.is_gecko) 
     3231  if( 0 && HTMLArea.is_gecko ) 
    28573232  { 
    28583233    var s = this._getSelection(); 
    28593234    // If the last character in the last text node of the parent tag 
    28603235    // and the parent tag is not a block tag 
    2861     if(s && s.isCollapsed && s.anchorNode 
    2862          && s.anchorNode.parentNode.tagName.toLowerCase() != 'body' 
    2863          && s.anchorNode.nodeType == 3 && s.anchorOffset == s.anchorNode.length 
    2864          && ! 
    2865           (   s.anchorNode.parentNode.nextSibling 
    2866            && s.anchorNode.parentNode.nextSibling.nodeType == 3 
    2867           ) 
    2868          && !HTMLArea.isBlockElement(s.anchorNode.parentNode) 
    2869       ) 
     3236    if ( s && s.isCollapsed && s.anchorNode && 
     3237         s.anchorNode.parentNode.tagName.toLowerCase() != 'body' && 
     3238         s.anchorNode.nodeType == 3 && s.anchorOffset == s.anchorNode.length && 
     3239         !( s.anchorNode.parentNode.nextSibling && s.anchorNode.parentNode.nextSibling.nodeType == 3 ) && 
     3240         !HTMLArea.isBlockElement(s.anchorNode.parentNode) ) 
    28703241    { 
    28713242      // Insert hair-width-space after the close tag if there isn't another text node on the other side 
     
    28743245      try 
    28753246      { 
    2876         s.anchorNode.parentNode.parentNode.insertBefore 
    2877           (this._doc.createTextNode('\t'), s.anchorNode.parentNode.nextSibling); 
    2878       } 
    2879       catch(e) 
    2880       { 
    2881         // Disregard 
    2882       } 
     3247        s.anchorNode.parentNode.parentNode.insertBefore(this._doc.createTextNode('\t'), s.anchorNode.parentNode.nextSibling); 
     3248      } 
     3249      catch(ex) {} // Disregard 
    28833250    } 
    28843251  } 
    28853252 
    28863253  // check if any plugins have registered refresh handlers 
    2887   for (var indexPlugin in this.plugins) 
     3254  for ( var indexPlugin in this.plugins ) 
    28883255  { 
    28893256    var plugin = this.plugins[indexPlugin].instance; 
    2890     if (plugin && typeof plugin.onUpdateToolbar == "function") 
     3257    if ( plugin && typeof plugin.onUpdateToolbar == "function" ) 
    28913258    { 
    28923259      plugin.onUpdateToolbar(); 
    28933260    } 
    28943261  } 
    2895  
    28963262 
    28973263}; 
     
    29003266 * selection.  The selection is removed.  It splits a text node, if needed. 
    29013267 */ 
    2902 if (!HTMLArea.is_ie) 
     3268if ( !HTMLArea.is_ie ) 
    29033269{ 
    29043270  HTMLArea.prototype.insertNodeAtSelection = function(toBeInserted) 
     
    29123278    var pos = range.startOffset; 
    29133279    var selnode = toBeInserted; 
    2914     switch (node.nodeType) 
     3280    switch ( node.nodeType ) 
    29153281    { 
    29163282      case 3: // Node.TEXT_NODE 
    29173283        // we have to split it at the caret position. 
    2918         if (toBeInserted.nodeType == 3) 
     3284        if ( toBeInserted.nodeType == 3 ) 
    29193285        { 
    29203286          // do optimized insertion 
     
    29283294        { 
    29293295          node = node.splitText(pos); 
    2930           if (toBeInserted.nodeType == 11 /* Node.DOCUMENT_FRAGMENT_NODE */) 
     3296          if ( toBeInserted.nodeType == 11 /* Node.DOCUMENT_FRAGMENT_NODE */ ) 
    29313297          { 
    29323298            selnode = selnode.firstChild; 
     
    29383304      break; 
    29393305      case 1: // Node.ELEMENT_NODE 
    2940         if (toBeInserted.nodeType == 11 /* Node.DOCUMENT_FRAGMENT_NODE */) 
     3306        if ( toBeInserted.nodeType == 11 /* Node.DOCUMENT_FRAGMENT_NODE */ ) 
    29413307        { 
    29423308          selnode = selnode.firstChild; 
     
    29583324 
    29593325// Returns the deepest node that contains both endpoints of the selection. 
    2960 if (HTMLArea.is_ie) 
     3326if ( HTMLArea.is_ie ) 
    29613327{ 
    29623328  HTMLArea.prototype.getParentElement = function(sel) 
    29633329  { 
    2964     if(typeof sel == 'undefined') 
     3330    if ( typeof sel == 'undefined' ) 
    29653331    { 
    29663332      sel = this._getSelection(); 
    29673333    } 
    29683334    var range = this._createRange(sel); 
    2969     switch (sel.type) 
     3335    switch ( sel.type ) 
    29703336    { 
    29713337      case "Text": 
     
    29733339        // the parent returned is not always the real parent element 
    29743340        var parent = range.parentElement(); 
    2975         while (true) 
     3341        while ( true ) 
    29763342        { 
    29773343          var TestRange = range.duplicate(); 
    29783344          TestRange.moveToElementText(parent); 
    2979           if (TestRange.inRange(range)) 
     3345          if ( TestRange.inRange(range) ) 
    29803346          { 
    29813347            break; 
    29823348          } 
    2983           if ((parent.nodeType != 1) || (parent.tagName.toLowerCase() == 'body')) 
     3349          if ( ( parent.nodeType != 1 ) || ( parent.tagName.toLowerCase() == 'body' ) ) 
    29843350          { 
    29853351            break; 
     
    30063372  HTMLArea.prototype.getParentElement = function(sel) 
    30073373  { 
    3008     if(typeof sel == 'undefined') 
     3374    if ( typeof sel == 'undefined' ) 
    30093375    { 
    30103376      sel = this._getSelection(); 
     
    30143380    { 
    30153381      var p = range.commonAncestorContainer; 
    3016       if (!range.collapsed && range.startContainer == range.endContainer && 
    3017           range.startOffset - range.endOffset <= 1 && range.startContainer.hasChildNodes()) 
     3382      if ( !range.collapsed && range.startContainer == range.endContainer && 
     3383          range.startOffset - range.endOffset <= 1 && range.startContainer.hasChildNodes() ) 
    30183384      { 
    30193385        p = range.startContainer.childNodes[range.startOffset]; 
     
    30233389            range.endContainer + ":" + range.endOffset); 
    30243390      */ 
    3025       while (p.nodeType == 3) 
     3391      while ( p.nodeType == 3 ) 
    30263392      { 
    30273393        p = p.parentNode; 
     
    30293395      return p; 
    30303396    } 
    3031     catch (e) 
     3397    catch (ex) 
    30323398    { 
    30333399      return null; 
     
    30373403 
    30383404// Returns an array with all the ancestor nodes of the selection. 
    3039 HTMLArea.prototype.getAllAncestors = function() { 
     3405HTMLArea.prototype.getAllAncestors = function() 
     3406{ 
    30403407  var p = this.getParentElement(); 
    30413408  var a = []; 
    3042   while (p && (p.nodeType == 1) && (p.tagName.toLowerCase() != 'body')) { 
     3409  while ( p && (p.nodeType == 1) && ( p.tagName.toLowerCase() != 'body' ) ) 
     3410  { 
    30433411    a.push(p); 
    30443412    p = p.parentNode; 
     
    30523420{ 
    30533421  var prnt = this._activeElement(sel); 
    3054   if(prnt === null) 
     3422  if ( prnt === null ) 
    30553423  { 
    30563424    try 
     
    30583426      prnt = (HTMLArea.is_ie ? this._createRange(sel).parentElement() : this._createRange(sel).commonAncestorContainer); 
    30593427    } 
    3060     catch(e) 
     3428    catch(ex) 
    30613429    { 
    30623430      return null; 
     
    30643432  } 
    30653433 
    3066   if(typeof types == 'string') 
     3434  if ( typeof types == 'string' ) 
    30673435  { 
    30683436    types = [types]; 
    30693437  } 
    30703438 
    3071   while(prnt) 
    3072   { 
    3073     if(prnt.nodeType == 1) 
    3074     { 
    3075       if(types === null) { return prnt; } 
    3076       if(types.contains(prnt.tagName.toLowerCase())) 
    3077       { 
    3078  
     3439  while ( prnt ) 
     3440  { 
     3441    if ( prnt.nodeType == 1 ) 
     3442    { 
     3443      if ( types === null ) 
     3444      { 
    30793445        return prnt; 
    30803446      } 
    3081       if(prnt.tagName.toLowerCase() == 'body') { break; } 
    3082       if(prnt.tagName.toLowerCase() == 'table') { break; } 
     3447      if ( types.contains(prnt.tagName.toLowerCase()) ) 
     3448      { 
     3449        return prnt; 
     3450      } 
     3451      if ( prnt.tagName.toLowerCase() == 'body' ) 
     3452      { 
     3453        break; 
     3454      } 
     3455      if ( prnt.tagName.toLowerCase() == 'table' ) 
     3456      { 
     3457        break; 
     3458      } 
    30833459    } 
    30843460    prnt = prnt.parentNode; 
     
    30953471 * @returns null | element 
    30963472 */ 
    3097 if(HTMLArea.is_ie) 
     3473if ( HTMLArea.is_ie ) 
    30983474{ 
    30993475  HTMLArea.prototype._activeElement = function(sel) 
    31003476  { 
    3101     if((sel === null) || this._selectionEmpty(sel)) 
     3477    if ( ( sel === null ) || this._selectionEmpty(sel) ) 
    31023478    { 
    31033479      return null; 
    31043480    } 
    31053481 
    3106     if(sel.type.toLowerCase() == "control") 
     3482    if ( sel.type.toLowerCase() == "control" ) 
    31073483    { 
    31083484      return sel.createRange().item(0); 
     
    31153491      var range = sel.createRange(); 
    31163492      var p_elm = this.getParentElement(sel); 
    3117       if(p_elm.innerHTML == range.htmlText) 
     3493      if ( p_elm.innerHTML == range.htmlText ) 
    31183494      { 
    31193495        return p_elm; 
    31203496      } 
    31213497      /* 
    3122       if(p_elm) 
     3498      if ( p_elm ) 
    31233499      { 
    31243500        var p_rng = this._doc.body.createTextRange(); 
    31253501        p_rng.moveToElementText(p_elm); 
    3126         if(p_rng.isEqual(range)) 
     3502        if ( p_rng.isEqual(range) ) 
    31273503        { 
    31283504          return p_elm; 
     
    31303506      } 
    31313507 
    3132       if(range.parentElement()) 
     3508      if ( range.parentElement() ) 
    31333509      { 
    31343510        var prnt_range = this._doc.body.createTextRange(); 
    31353511        prnt_range.moveToElementText(range.parentElement()); 
    3136         if(prnt_range.isEqual(range)) 
     3512        if ( prnt_range.isEqual(range) ) 
    31373513        { 
    31383514          return range.parentElement(); 
     
    31483524  HTMLArea.prototype._activeElement = function(sel) 
    31493525  { 
    3150     if((sel === null) || this._selectionEmpty(sel)) 
     3526    if ( ( sel === null ) || this._selectionEmpty(sel) ) 
    31513527    { 
    31523528      return null; 
     
    31563532    // and that the anchor (start of selection) is an element.  This might not be totally 
    31573533    // correct, we possibly should do a simlar check to IE? 
    3158     if(! sel.isCollapsed) 
    3159     { 
    3160       if(sel.anchorNode.childNodes.length > sel.anchorOffset && sel.anchorNode.childNodes[sel.anchorOffset].nodeType == 1) 
     3534    if ( !sel.isCollapsed ) 
     3535    { 
     3536      if ( sel.anchorNode.childNodes.length > sel.anchorOffset && sel.anchorNode.childNodes[sel.anchorOffset].nodeType == 1 ) 
    31613537      { 
    31623538        return sel.anchorNode.childNodes[sel.anchorOffset]; 
    31633539      } 
    3164       else if(sel.anchorNode.nodeType == 1) 
     3540      else if ( sel.anchorNode.nodeType == 1 ) 
    31653541      { 
    31663542        return sel.anchorNode; 
     
    31753551} 
    31763552 
    3177 if(HTMLArea.is_ie) 
     3553if ( HTMLArea.is_ie ) 
    31783554{ 
    31793555  HTMLArea.prototype._selectionEmpty = function(sel) 
    31803556  { 
    3181     if(!sel) 
     3557    if ( !sel ) 
    31823558    { 
    31833559      return true; 
     
    31913567  HTMLArea.prototype._selectionEmpty = function(sel) 
    31923568  { 
    3193     if(!sel) 
     3569    if ( !sel ) 
    31943570    { 
    31953571      return true; 
    31963572    } 
    31973573 
    3198     if(typeof sel.isCollapsed != 'undefined') 
     3574    if ( typeof sel.isCollapsed != 'undefined' ) 
    31993575    { 
    32003576      return sel.isCollapsed; 
     
    32103586  var prnt = (HTMLArea.is_ie ? this._createRange(sel).parentElement : this._createRange(sel).commonAncestorContainer); 
    32113587 
    3212   while(prnt && (prnt.nodeType == 1)) 
    3213   { 
    3214     switch(prnt.tagName.toLowerCase()) 
    3215     { 
    3216       case 'div' : 
    3217       case 'p'   : 
    3218       case 'address'    : 
    3219       case 'blockquote' : 
    3220       case 'center'  : 
    3221       case 'del'     : 
    3222       case 'ins'     : 
    3223       case 'pre'     : 
    3224       case 'h1'      : 
    3225       case 'h2'      : 
    3226       case 'h3'      : 
    3227       case 'h4'      : 
    3228       case 'h5'      : 
    3229       case 'h6'      : 
    3230       case 'h7'      : 
     3588  while ( prnt && ( prnt.nodeType == 1 ) ) 
     3589  { 
     3590    switch ( prnt.tagName.toLowerCase() ) 
     3591    { 
     3592      case 'div': 
     3593      case 'p': 
     3594      case 'address': 
     3595      case 'blockquote': 
     3596      case 'center': 
     3597      case 'del': 
     3598      case 'ins': 
     3599      case 'pre': 
     3600      case 'h1': 
     3601      case 'h2': 
     3602      case 'h3': 
     3603      case 'h4': 
     3604      case 'h5': 
     3605      case 'h6': 
     3606      case 'h7': 
    32313607        // Block Element 
    32323608        return prnt; 
    32333609 
    3234       case 'body'     : 
    3235       case 'noframes' : 
    3236       case 'dd'  : 
    3237       case 'li'  : 
    3238       case 'th'  : 
    3239       case 'td'  : 
     3610      case 'body': 
     3611      case 'noframes': 
     3612      case 'dd': 
     3613      case 'li': 
     3614      case 'th': 
     3615      case 'td': 
    32403616      case 'noscript' : 
    32413617        // Halting element (stop searching) 
    32423618        return null; 
    32433619 
    3244       default : 
     3620      default: 
    32453621        // Keep lookin 
    32463622        break; 
     
    32563632  // then wrap the selection in a block and return 
    32573633  var sel = this._getSelection(); 
    3258   if(HTMLArea.is_ie) 
     3634  if ( HTMLArea.is_ie ) 
    32593635  { 
    32603636    sel.empty(); 
     
    32813657  var target_classNames = [ ]; 
    32823658 
    3283   if(block_format.indexOf('.') >= 0) 
     3659  if ( block_format.indexOf('.') >= 0 ) 
    32843660  { 
    32853661    target_tag = block_format.substr(0, block_format.indexOf('.')).toLowerCase(); 
     
    32943670  var rng = this._createRange(sel); 
    32953671 
    3296   if(HTMLArea.is_gecko) 
    3297   { 
    3298     if(sel.isCollapsed) 
     3672  if ( HTMLArea.is_gecko ) 
     3673  { 
     3674    if ( sel.isCollapsed ) 
    32993675    { 
    33003676      // With no selection we want to apply to the whole contents of the ancestor block 
    33013677      apply_to = this._getAncestorBlock(sel); 
    3302       if(apply_to === null) 
     3678      if ( apply_to === null ) 
    33033679      { 
    33043680        // If there wasn't an ancestor, make one. 
     
    33093685    { 
    33103686      // With a selection it's more tricky 
    3311       switch(target_tag) 
     3687      switch ( target_tag ) 
    33123688      { 
    33133689 
     
    33193695        case 'h6': 
    33203696        case 'h7': 
    3321           apply_to = [ ]; 
     3697          apply_to = []; 
    33223698          var search_tags = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'h7']; 
    3323           for(var y = 0; y < search_tags.length; y++) 
     3699          for ( var y = 0; y < search_tags.length; y++ ) 
    33243700          { 
    33253701            var headers = this._doc.getElementsByTagName(search_tags[y]); 
    3326             for(x = 0; x < headers.length; x++) 
     3702            for ( x = 0; x < headers.length; x++ ) 
    33273703            { 
    3328               if(sel.containsNode(headers[x])) 
     3704              if ( sel.containsNode(headers[x]) ) 
    33293705              { 
    33303706                apply_to[apply_to.length] = headers[x]; 
     
    33323708            } 
    33333709          } 
    3334           if(apply_to.length > 0) { break; } 
     3710          if ( apply_to.length > 0) 
     3711          { 
     3712            break; 
     3713          } 
    33353714          // If there wern't any in the selection drop through 
    33363715        case 'div': 
     
    33473726        case 'blockquote': 
    33483727        case 'address': 
    3349           apply_to = [ ]; 
     3728          apply_to = []; 
    33503729          var paras = this._doc.getElementsByTagName(target_tag); 
    3351           for(x = 0; x < paras.length; x++) 
     3730          for ( x = 0; x < paras.length; x++ ) 
    33523731          { 
    3353             if(sel.containsNode(paras[x])) 
     3732            if ( sel.containsNode(paras[x]) ) 
    33543733            { 
    33553734              apply_to[apply_to.length] = paras[x]; 
     
    33573736          } 
    33583737 
    3359           if(apply_to.length === 0) 
     3738          if ( apply_to.length === 0 ) 
    33603739          { 
    33613740            sel.collapseToStart(); 
     
    33703749 
    33713750// Selects the contents inside the given node 
    3372 if (HTMLArea.is_ie) 
     3751if ( HTMLArea.is_ie ) 
    33733752{ 
    33743753  HTMLArea.prototype.selectNodeContents = function(node, pos) 
     
    33793758    var collapsed = typeof pos == "undefined" ? true : false; 
    33803759    // Tables and Images get selected as "objects" rather than the text contents 
    3381     if(collapsed && node.tagName && node.tagName.toLowerCase().match(/table|img|input|select|textarea/)) 
     3760    if ( collapsed && node.tagName && node.tagName.toLowerCase().match(/table|img|input|select|textarea/) ) 
    33823761    { 
    33833762      range = this._doc.body.createControlRange(); 
     
    34043783    range = this._doc.createRange(); 
    34053784    // Tables and Images get selected as "objects" rather than the text contents 
    3406     if(collapsed && node.tagName && node.tagName.toLowerCase().match(/table|img|input|textarea|select/)) 
     3785    if ( collapsed && node.tagName && node.tagName.toLowerCase().match(/table|img|input|textarea|select/) ) 
    34073786    { 
    34083787      range.selectNode(node); 
     
    34213800 * the selection, if any. 
    34223801 */ 
    3423 if (HTMLArea.is_ie) 
     3802if ( HTMLArea.is_ie ) 
    34243803{ 
    34253804  HTMLArea.prototype.insertHTML = function(html) 
     
    34423821    var div = this._doc.createElement("div"); 
    34433822    div.innerHTML = html; 
    3444     while (div.firstChild) 
     3823    while ( div.firstChild ) 
    34453824    { 
    34463825      // the following call also removes the node from div 
     
    34553834 *  Call this function to surround the existing HTML code in the selection with 
    34563835 *  your tags.  FIXME: buggy!  This function will be deprecated "soon". 
     3836 * @todo: when will it be deprecated ? Can it be removed already ? 
    34573837 */ 
    3458 HTMLArea.prototype.surroundHTML = function(startTag, endTag) { 
     3838HTMLArea.prototype.surroundHTML = function(startTag, endTag) 
     3839{ 
    34593840  var html = this.getSelectedHTML(); 
    34603841  // the following also deletes the selection 
     
    34633844 
    34643845/// Retrieve the selected block 
    3465 if (HTMLArea.is_ie) 
     3846if ( HTMLArea.is_ie ) 
    34663847{ 
    34673848  HTMLArea.prototype.getSelectedHTML = function() 
     
    34833864 
    34843865/// Return true if we have some selection 
    3485 HTMLArea.prototype.hasSelectedText = function() { 
     3866HTMLArea.prototype.hasSelectedText = function() 
     3867{ 
    34863868  // FIXME: come _on_ mishoo, you can do better than this ;-) 
    34873869  return this.getSelectedHTML() !== ''; 
    34883870}; 
    34893871 
    3490 HTMLArea.prototype._createLink = function(link) { 
     3872HTMLArea.prototype._createLink = function(link) 
     3873{ 
    34913874  var editor = this; 
    34923875  var outparam = null; 
    3493   if (typeof link == "undefined") { 
     3876  if ( typeof link == "undefined" ) 
     3877  { 
    34943878    link = this.getParentElement(); 
    3495     if (link) { 
    3496       while (link && link.tagName.toLowerCase() != 'a') 
     3879    if ( link ) 
     3880    { 
     3881      while ( link && link.tagName.toLowerCase() != 'a' ) 
    34973882      { 
    34983883        link = link.parentNode; 
     
    35003885    } 
    35013886  } 
    3502   if (!link) { 
     3887  if ( !link ) 
     3888  { 
    35033889    var sel = editor._getSelection(); 
    35043890    var range = editor._createRange(sel); 
    35053891    var compare = 0; 
    3506     if (HTMLArea.is_ie) { 
    3507       if(sel.type == "Control") 
     3892    if ( HTMLArea.is_ie ) 
     3893    { 
     3894      if ( sel.type == "Control" ) 
    35083895      { 
    35093896        compare = range.length; 
     
    35133900        compare = range.compareEndPoints("StartToEnd", range); 
    35143901      } 
    3515     } else { 
     3902    } 
     3903    else 
     3904    { 
    35163905      compare = range.compareBoundaryPoints(range.START_TO_END, range); 
    35173906    } 
    3518     if (compare === 0) { 
     3907    if ( compare === 0 ) 
     3908    { 
    35193909      alert(HTMLArea._lc("You need to select some text before creating a link")); 
    35203910      return; 
    35213911    } 
    3522     outparam = { 
     3912    outparam = 
     3913    { 
    35233914      f_href : '', 
    35243915      f_title : '', 
     
    35263917      f_usetarget : editor.config.makeLinkShowsTarget 
    35273918    }; 
    3528   } else { 
    3529     outparam = { 
     3919  } 
     3920  else 
     3921  { 
     3922    outparam = 
     3923    { 
    35303924      f_href   : HTMLArea.is_ie ? editor.stripBaseURL(link.href) : link.getAttribute("href"), 
    35313925      f_title  : link.title, 
     
    35343928    }; 
    35353929  } 
    3536   this._popupDialog(editor.config.URIs.link, function(param) { 
    3537     if (!param) { 
    3538       return false; 
    3539     } 
    3540     var a = link; 
    3541     if (!a) { try { 
    3542       editor._doc.execCommand("createlink", false, param.f_href); 
    3543       a = editor.getParentElement(); 
    3544       var sel = editor._getSelection(); 
    3545       var range = editor._createRange(sel); 
    3546       if (!HTMLArea.is_ie) { 
    3547         a = range.startContainer; 
    3548         if (a.tagName.toLowerCase() != 'a') { 
    3549           a = a.nextSibling; 
    3550           if (a === null) 
     3930  this._popupDialog( 
     3931    editor.config.URIs.link, 
     3932    function(param) 
     3933    { 
     3934      if ( !param ) 
     3935      { 
     3936        return false; 
     3937      } 
     3938      var a = link; 
     3939      if ( !a ) 
     3940      { 
     3941        try 
     3942        { 
     3943          editor._doc.execCommand("createlink", false, param.f_href); 
     3944          a = editor.getParentElement(); 
     3945          var sel = editor._getSelection(); 
     3946          var range = editor._createRange(sel); 
     3947          if ( !HTMLArea.is_ie ) 
    35513948          { 
    3552             a = range.startContainer.parentNode; 
     3949            a = range.startContainer; 
     3950            if ( a.tagName.toLowerCase() != 'a' ) 
     3951            { 
     3952              a = a.nextSibling; 
     3953              if ( a === null ) 
     3954              { 
     3955                a = range.startContainer.parentNode; 
     3956              } 
     3957            } 
    35533958          } 
    3554         } 
    3555       } 
    3556     } catch(e) {} 
    3557     } else { 
    3558       var href = param.f_href.trim(); 
     3959        } catch(ex) {} 
     3960      } 
     3961      else 
     3962      { 
     3963        var href = param.f_href.trim(); 
     3964        editor.selectNodeContents(a); 
     3965        if ( href === '' ) 
     3966        { 
     3967          editor._doc.execCommand("unlink", false, null); 
     3968          editor.updateToolbar(); 
     3969          return false; 
     3970        } 
     3971        else 
     3972        { 
     3973          a.href = href; 
     3974        } 
     3975      } 
     3976      if ( ! ( a && a.tagName.toLowerCase() == 'a' ) ) 
     3977      { 
     3978        return false; 
     3979      } 
     3980      a.target = param.f_target.trim(); 
     3981      a.title = param.f_title.trim(); 
    35593982      editor.selectNodeContents(a); 
    3560       if (href === '') { 
    3561         editor._doc.execCommand("unlink", false, null); 
    3562         editor.updateToolbar(); 
    3563         return false; 
    3564       } 
    3565       else { 
    3566         a.href = href; 
    3567       } 
    3568     } 
    3569     if (!(a && a.tagName.toLowerCase() == 'a')) { 
    3570       return false; 
    3571     } 
    3572     a.target = param.f_target.trim(); 
    3573     a.title = param.f_title.trim(); 
    3574     editor.selectNodeContents(a); 
    3575     editor.updateToolbar(); 
    3576   }, outparam); 
     3983      editor.updateToolbar(); 
     3984    }, 
     3985    outparam); 
    35773986}; 
    35783987 
    35793988// Called when the user clicks on "InsertImage" button.  If an image is already 
    35803989// there, it will just modify it's properties. 
    3581 HTMLArea.prototype._insertImage = function(image) { 
     3990HTMLArea.prototype._insertImage = function(image) 
     3991{ 
    35823992  var editor = this;    // for nested functions 
    35833993  var outparam = null; 
    3584   if (typeof image == "undefined") { 
     3994  if ( typeof image == "undefined" ) 
     3995  { 
    35853996    image = this.getParentElement(); 
    3586     if (image && image.tagName.toLowerCase() != 'img') { 
     3997    if ( image && image.tagName.toLowerCase() != 'img' ) 
     3998    { 
    35873999      image = null; 
    35884000    } 
    35894001  } 
    3590   if (image) 
    3591   { 
    3592     outparam = { 
     4002  if ( image ) 
     4003  { 
     4004    outparam = 
     4005    { 
    35934006      f_base   : editor.config.baseHref, 
    35944007      f_url    : HTMLArea.is_ie ? editor.stripBaseURL(image.src) : image.getAttribute("src"), 
     
    36004013    }; 
    36014014  } 
    3602   this._popupDialog(editor.config.URIs.insert_image, function(param) { 
    3603     if (!param) {       // user must have pressed Cancel 
    3604       return false; 
    3605     } 
    3606     var img = image; 
    3607     if (!img) {       
    3608       if (HTMLArea.is_ie) { 
    3609         var sel = editor._getSelection(); 
    3610         var range = editor._createRange(sel); 
    3611         editor._doc.execCommand("insertimage", false, param.f_url); 
    3612         img = range.parentElement(); 
    3613         // wonder if this works... 
    3614         if (img.tagName.toLowerCase() != "img") { 
    3615           img = img.previousSibling; 
    3616         } 
    3617       } else { 
    3618         img = document.createElement('img'); 
     4015  this._popupDialog( 
     4016    editor.config.URIs.insert_image, 
     4017    function(param) 
     4018    { 
     4019      // user must have pressed Cancel 
     4020      if ( !param ) 
     4021      { 
     4022        return false; 
     4023      } 
     4024      var img = image; 
     4025      if ( !img ) 
     4026      { 
     4027        if ( HTMLArea.is_ie ) 
     4028        { 
     4029          var sel = editor._getSelection(); 
     4030          var range = editor._createRange(sel); 
     4031          editor._doc.execCommand("insertimage", false, param.f_url); 
     4032          img = range.parentElement(); 
     4033          // wonder if this works... 
     4034          if ( img.tagName.toLowerCase() != "img" ) 
     4035          { 
     4036            img = img.previousSibling; 
     4037          } 
     4038        } 
     4039        else 
     4040        { 
     4041          img = document.createElement('img'); 
     4042          img.src = param.f_url; 
     4043          editor.insertNodeAtSelection(img); 
     4044          if ( !img.tagName ) 
     4045          { 
     4046            // if the cursor is at the beginning of the document 
     4047            img = range.startContainer.firstChild; 
     4048          } 
     4049        } 
     4050      } 
     4051      else 
     4052      { 
    36194053        img.src = param.f_url; 
    3620         editor.insertNodeAtSelection(img); 
    3621         if (!img.tagName) { 
    3622           // if the cursor is at the beginning of the document 
    3623           img = range.startContainer.firstChild; 
    3624         } 
    3625       } 
    3626     } else { 
    3627       img.src = param.f_url; 
    3628     } 
    3629  
    3630     for (var field in param) { 
    3631       var value = param[field]; 
    3632       switch (field) { 
    3633           case "f_alt"    : img.alt      = value; break; 
    3634           case "f_border" : img.border = parseInt(value || "0", 10); break; 
    3635           case "f_align"  : img.align    = value; break; 
    3636           case "f_vert"   : img.vspace = parseInt(value || "0", 10); break; 
    3637           case "f_horiz"  : img.hspace = parseInt(value || "0", 10); break; 
    3638       } 
    3639     } 
    3640   }, outparam); 
     4054      } 
     4055 
     4056      for ( var field in param ) 
     4057      { 
     4058        var value = param[field]; 
     4059        switch (field) 
     4060        { 
     4061          case "f_alt": 
     4062            img.alt = value; 
     4063          break; 
     4064          case "f_border": 
     4065            img.border = parseInt(value || "0", 10); 
     4066          break; 
     4067          case "f_align": 
     4068            img.align = value; 
     4069          break; 
     4070          case "f_vert": 
     4071            img.vspace = parseInt(value || "0", 10); 
     4072          break; 
     4073          case "f_horiz": 
     4074            img.hspace = parseInt(value || "0", 10); 
     4075          break; 
     4076        } 
     4077      } 
     4078    }, 
     4079    outparam); 
    36414080}; 
    36424081 
    36434082// Called when the user clicks the Insert Table button 
    3644 HTMLArea.prototype._insertTable = function() { 
     4083HTMLArea.prototype._insertTable = function() 
     4084{ 
    36454085  var sel = this._getSelection(); 
    36464086  var range = this._createRange(sel); 
    36474087  var editor = this;    // for nested functions 
    3648   this._popupDialog(editor.config.URIs.insert_table, function(param) { 
    3649     if (!param) {       // user must have pressed Cancel 
    3650       return false; 
    3651     } 
    3652     var doc = editor._doc; 
    3653     // create the table element 
    3654     var table = doc.createElement("table"); 
    3655     // assign the given arguments 
    3656  
    3657     for (var field in param) { 
    3658       var value = param[field]; 
    3659       if (!value) { 
    3660         continue; 
    3661       } 
    3662       switch (field) { 
    3663           case "f_width"   : table.style.width = value + param.f_unit; break; 
    3664           case "f_align"   : table.align         = value; break; 
    3665           case "f_border"  : table.border        = parseInt(value, 10); break; 
    3666           case "f_spacing" : table.cellSpacing = parseInt(value, 10); break; 
    3667           case "f_padding" : table.cellPadding = parseInt(value, 10); break; 
    3668       } 
    3669     } 
    3670     var cellwidth = 0; 
    3671     if (param.f_fixed) { 
    3672       cellwidth = Math.floor(100 / parseInt(param.f_cols, 10)); 
    3673     } 
    3674     var tbody = doc.createElement("tbody"); 
    3675     table.appendChild(tbody); 
    3676     for (var i = 0; i < param.f_rows; ++i) { 
    3677       var tr = doc.createElement("tr"); 
    3678       tbody.appendChild(tr); 
    3679       for (var j = 0; j < param.f_cols; ++j) { 
    3680         var td = doc.createElement("td"); 
    3681         // @todo : check if this line doesnt stop us to use pixel width in cells 
    3682         if (cellwidth) { 
    3683           td.style.width = cellwidth + "%"; 
    3684         } 
    3685         tr.appendChild(td); 
    3686         // Browsers like to see something inside the cell (&nbsp;). 
    3687         td.appendChild(doc.createTextNode('\u00a0')); 
    3688       } 
    3689     } 
    3690     if (HTMLArea.is_ie) { 
    3691       range.pasteHTML(table.outerHTML); 
    3692     } else { 
    3693       // insert the table 
    3694       editor.insertNodeAtSelection(table); 
    3695     } 
    3696     return true; 
    3697   }, null); 
     4088  this._popupDialog( 
     4089    editor.config.URIs.insert_table, 
     4090    function(param) 
     4091    { 
     4092      // user must have pressed Cancel 
     4093      if ( !param ) 
     4094      { 
     4095        return false; 
     4096      } 
     4097      var doc = editor._doc; 
     4098      // create the table element 
     4099      var table = doc.createElement("table"); 
     4100      // assign the given arguments 
     4101 
     4102      for ( var field in param ) 
     4103      { 
     4104        var value = param[field]; 
     4105        if ( !value ) 
     4106        { 
     4107          continue; 
     4108        } 
     4109        switch (field) 
     4110        { 
     4111          case "f_width": 
     4112            table.style.width = value + param.f_unit; 
     4113          break; 
     4114          case "f_align": 
     4115            table.align = value; 
     4116          break; 
     4117          case "f_border": 
     4118            table.border = parseInt(value, 10); 
     4119          break; 
     4120          case "f_spacing": 
     4121            table.cellSpacing = parseInt(value, 10); 
     4122          break; 
     4123          case "f_padding": 
     4124            table.cellPadding = parseInt(value, 10); 
     4125          break; 
     4126        } 
     4127      } 
     4128      var cellwidth = 0; 
     4129      if ( param.f_fixed ) 
     4130      { 
     4131        cellwidth = Math.floor(100 / parseInt(param.f_cols, 10)); 
     4132      } 
     4133      var tbody = doc.createElement("tbody"); 
     4134      table.appendChild(tbody); 
     4135      for ( var i = 0; i < param.f_rows; ++i ) 
     4136      { 
     4137        var tr = doc.createElement("tr"); 
     4138        tbody.appendChild(tr); 
     4139        for ( var j = 0; j < param.f_cols; ++j ) 
     4140        { 
     4141          var td = doc.createElement("td"); 
     4142          // @todo : check if this line doesnt stop us to use pixel width in cells 
     4143          if (cellwidth) 
     4144          { 
     4145            td.style.width = cellwidth + "%"; 
     4146          } 
     4147          tr.appendChild(td); 
     4148          // Browsers like to see something inside the cell (&nbsp;). 
     4149          td.appendChild(doc.createTextNode('\u00a0')); 
     4150        } 
     4151      } 
     4152      if ( HTMLArea.is_ie ) 
     4153      { 
     4154        range.pasteHTML(table.outerHTML); 
     4155      } 
     4156      else 
     4157      { 
     4158        // insert the table 
     4159        editor.insertNodeAtSelection(table); 
     4160      } 
     4161      return true; 
     4162    }, 
     4163    null 
     4164  ); 
    36984165}; 
    36994166 
     
    37044171// el is reference to the SELECT object 
    37054172// txt is the name of the select field, as in config.toolbar 
    3706 HTMLArea.prototype._comboSelected = function(el, txt) { 
     4173HTMLArea.prototype._comboSelected = function(el, txt) 
     4174{ 
    37074175  this.focusEditor(); 
    37084176  var value = el.options[el.selectedIndex].value; 
    3709   switch (txt) { 
    3710       case "fontname": 
    3711       case "fontsize": this.execCommand(txt, false, value); break; 
    3712       case "formatblock": 
    3713     // (HTMLArea.is_ie) && (value = "<" + value + ">"); 
    3714     if(!HTMLArea.is_gecko || value !== 'blockquote') {   value = "<" + value + ">";} 
    3715     this.execCommand(txt, false, value); 
     4177  switch (txt) 
     4178  { 
     4179    case "fontname": 
     4180    case "fontsize": 
     4181      this.execCommand(txt, false, value); 
    37164182    break; 
    3717       default: 
    3718     // try to look it up in the registered dropdowns 
    3719     var dropdown = this.config.customSelects[txt]; 
    3720     if (typeof dropdown != "undefined") { 
    3721       dropdown.action(this); 
    3722     } else { 
    3723       alert("FIXME: combo box " + txt + " not implemented"); 
    3724     } 
     4183    case "formatblock": 
     4184      // (HTMLArea.is_ie) && (value = "<" + value + ">"); 
     4185      if( !HTMLArea.is_gecko || value !== 'blockquote' ) 
     4186      { 
     4187        value = "<" + value + ">"; 
     4188      } 
     4189      this.execCommand(txt, false, value); 
     4190    break; 
     4191    default: 
     4192      // try to look it up in the registered dropdowns 
     4193      var dropdown = this.config.customSelects[txt]; 
     4194      if ( typeof dropdown != "undefined" ) 
     4195      { 
     4196        dropdown.action(this); 
     4197      } 
     4198      else 
     4199      { 
     4200        alert("FIXME: combo box " + txt + " not implemented"); 
     4201      } 
     4202    break; 
    37254203  } 
    37264204}; 
     
    37354213{ 
    37364214  var editor = this;    // for nested functions 
    3737   if (cmdID == 'hilitecolor') 
    3738   { 
    3739     if (HTMLArea.is_ie) { cmdID = 'backcolor'; } 
     4215  if ( cmdID == 'hilitecolor' ) 
     4216  { 
     4217    if ( HTMLArea.is_ie ) 
     4218    { 
     4219      cmdID = 'backcolor'; 
     4220    } 
    37404221    // @todo : useCSS is deprecated, see ticket #619 
    3741     if (HTMLArea.is_gecko) { try { editor._doc.execCommand('useCSS', false, false); } catch (e) {} } //switch on useCSS (mozilla bug #279330) 
    3742   } 
    3743   this._popupDialog(editor.config.URIs.select_color, function(color) { 
    3744     if (color) { // selection not canceled 
    3745       editor._doc.execCommand(cmdID, false, "#" + color); 
    3746     } 
    3747   }, HTMLArea._colorToRgb(this._doc.queryCommandValue(cmdID))); 
     4222    if ( HTMLArea.is_gecko ) 
     4223    { 
     4224      try 
     4225      { 
     4226        editor._doc.execCommand('useCSS', false, false); //switch on useCSS (mozilla bug #279330) 
     4227      } catch (ex) {} 
     4228    } 
     4229  } 
     4230  this._popupDialog( 
     4231    editor.config.URIs.select_color, 
     4232    function(color) 
     4233    { 
     4234      // selection not canceled 
     4235      if ( color ) 
     4236      { 
     4237        editor._doc.execCommand(cmdID, false, "#" + color); 
     4238      } 
     4239    }, 
     4240    HTMLArea._colorToRgb(this._doc.queryCommandValue(cmdID))); 
    37484241}; 
    37494242 
    37504243// the execCommand function (intercepts some commands and replaces them with 
    37514244// our own implementation) 
    3752 HTMLArea.prototype.execCommand = function(cmdID, UI, param) { 
     4245HTMLArea.prototype.execCommand = function(cmdID, UI, param) 
     4246{ 
    37534247  var editor = this;    // for nested functions 
    37544248  this.focusEditor(); 
    37554249  cmdID = cmdID.toLowerCase(); 
    37564250  // @todo : useCSS is deprecated, see ticket #619 
    3757   if (HTMLArea.is_gecko) { try { this._doc.execCommand('useCSS', false, true); } catch (e) {} } //switch useCSS off (true=off) 
    3758   switch (cmdID) { 
    3759     case "htmlmode" : this.setMode(); break; 
     4251  if ( HTMLArea.is_gecko ) 
     4252  { 
     4253    try 
     4254    { 
     4255      this._doc.execCommand('useCSS', false, true); //switch useCSS off (true=off) 
     4256    } catch (ex) {} 
     4257  } 
     4258  switch (cmdID) 
     4259  { 
     4260    case "htmlmode": 
     4261      this.setMode(); 
     4262    break; 
    37604263 
    37614264    case "hilitecolor": 
     
    37664269    case "createlink": 
    37674270      this._createLink(); 
    3768       break; 
    3769       case "undo": 
    3770       case "redo": 
    3771     if (this._customUndo) 
    3772     { 
    3773       this[cmdID](); 
    3774     } 
    3775     else 
     4271    break; 
     4272 
     4273    case "undo": 
     4274    case "redo": 
     4275      if (this._customUndo) 
     4276      { 
     4277        this[cmdID](); 
     4278      } 
     4279      else 
     4280      { 
     4281        this._doc.execCommand(cmdID, UI, param); 
     4282      } 
     4283    break; 
     4284 
     4285    case "inserttable": 
     4286      this._insertTable(); 
     4287    break; 
     4288 
     4289    case "insertimage": 
     4290      this._insertImage(); 
     4291    break; 
     4292 
     4293    case "about": 
     4294      this._popupDialog(editor.config.URIs.about, null, this); 
     4295    break; 
     4296 
     4297    case "showhelp": 
     4298      this._popupDialog(editor.config.URIs.help, null, this); 
     4299    break; 
     4300 
     4301    case "killword": 
     4302      this._wordClean(); 
     4303    break; 
     4304 
     4305    case "cut": 
     4306    case "copy": 
     4307    case "paste": 
     4308    try 
    37764309    { 
    37774310      this._doc.execCommand(cmdID, UI, param); 
     4311      if ( this.config.killWordOnPaste ) 
     4312      { 
     4313        this._wordClean(); 
     4314      } 
     4315    } 
     4316    catch (ex) 
     4317    { 
     4318      if ( HTMLArea.is_gecko ) 
     4319      { 
     4320        alert(HTMLArea._lc("The Paste button does not work in Mozilla based web browsers (technical security reasons). Press CTRL-V on your keyboard to paste directly.")); 
     4321      } 
    37784322    } 
    37794323    break; 
    3780       case "inserttable": this._insertTable(); break; 
    3781       case "insertimage": this._insertImage(); break; 
    3782       case "about"    : this._popupDialog(editor.config.URIs.about, null, this); break; 
    3783       case "showhelp" : this._popupDialog(editor.config.URIs.help, null, this); break; 
    3784  
    3785       case "killword": this._wordClean(); break; 
    3786  
    3787       case "cut": 
    3788       case "copy": 
    3789       case "paste": 
    3790     try { 
    3791       this._doc.execCommand(cmdID, UI, param); 
    3792       if (this.config.killWordOnPaste) { 
    3793         this._wordClean(); 
    3794       } 
    3795     } catch (e) { 
    3796       if (HTMLArea.is_gecko) { 
    3797         alert(HTMLArea._lc("The Paste button does not work in Mozilla based web browsers (technical security reasons). Press CTRL-V on your keyboard to paste directly.")); 
    3798       } 
    3799     } 
     4324    case "lefttoright": 
     4325    case "righttoleft": 
     4326      var dir = (cmdID == "righttoleft") ? "rtl" : "ltr"; 
     4327      var el = this.getParentElement(); 
     4328      while ( el && !HTMLArea.isBlockElement(el) ) 
     4329      { 
     4330        el = el.parentNode; 
     4331      } 
     4332      if ( el ) 
     4333      { 
     4334        if ( el.style.direction == dir ) 
     4335        { 
     4336          el.style.direction = ""; 
     4337        } 
     4338        else 
     4339        { 
     4340          el.style.direction = dir; 
     4341        } 
     4342      } 
    38004343    break; 
    3801       case "lefttoright": 
    3802       case "righttoleft": 
    3803     var dir = (cmdID == "righttoleft") ? "rtl" : "ltr"; 
    3804     var el = this.getParentElement(); 
    3805     while (el && !HTMLArea.isBlockElement(el)) { 
    3806       el = el.parentNode; 
    3807     } 
    3808     if (el) { 
    3809       if (el.style.direction == dir) 
    3810       { 
    3811         el.style.direction = ""; 
    3812       } 
    3813       else 
    3814       { 
    3815         el.style.direction = dir; 
    3816       } 
    3817     } 
     4344    default: 
     4345      try 
     4346      { 
     4347        this._doc.execCommand(cmdID, UI, param); 
     4348      } 
     4349      catch(ex) 
     4350      { 
     4351        if ( this.config.debug ) 
     4352        { 
     4353          alert(e + "\n\nby execCommand(" + cmdID + ");"); 
     4354        } 
     4355      } 
    38184356    break; 
    3819       default: try { this._doc.execCommand(cmdID, UI, param); } 
    3820     catch(e) { if (this.config.debug) { alert(e + "\n\nby execCommand(" + cmdID + ");"); } } 
    38214357  } 
    38224358 
     
    38284364 * @todo: this function is *TOO* generic, it needs to be splitted in more specific handlers 
    38294365 * This function also handles key bindings. */ 
    3830 HTMLArea.prototype._editorEvent = function(ev) { 
     4366HTMLArea.prototype._editorEvent = function(ev) 
     4367{ 
    38314368  var editor = this; 
    38324369  var keyEvent = (HTMLArea.is_ie && ev.type == "keydown") || (!HTMLArea.is_ie && ev.type == "keypress"); 
    38334370 
    38344371  //call events of textarea 
    3835   if(typeof editor._textArea['on'+ev.type] == "function") { 
     4372  if ( typeof editor._textArea['on'+ev.type] == "function" ) 
     4373  { 
    38364374    editor._textArea['on'+ev.type](); 
    38374375  } 
    38384376 
    3839   if(HTMLArea.is_gecko && keyEvent && ev.ctrlKey &&  this._unLink && this._unlinkOnUndo) 
    3840   { 
    3841     if(String.fromCharCode(ev.charCode).toLowerCase() == 'z') 
     4377  if ( HTMLArea.is_gecko && keyEvent && ev.ctrlKey &&  this._unLink && this._unlinkOnUndo ) 
     4378  { 
     4379    if ( String.fromCharCode(ev.charCode).toLowerCase() == 'z' ) 
    38424380    { 
    38434381      HTMLArea._stopEvent(ev); 
     
    38484386  } 
    38494387 
    3850   if (keyEvent) 
    3851   { 
    3852     for (var i in editor.plugins) 
     4388  if ( keyEvent ) 
     4389  { 
     4390    for ( var i in editor.plugins ) 
    38534391    { 
    38544392      var plugin = editor.plugins[i].instance; 
    3855       if (plugin && typeof plugin.onKeyPress == "function") 
    3856       { 
    3857         if (plugin.onKeyPress(ev)) 
     4393      if ( plugin && typeof plugin.onKeyPress == "function" ) 
     4394      { 
     4395        if ( plugin.onKeyPress(ev) ) 
    38584396        { 
    38594397          return false; 
     
    38634401  } 
    38644402 
    3865   if (keyEvent && ev.ctrlKey && !ev.altKey) 
     4403  if ( keyEvent && ev.ctrlKey && !ev.altKey ) 
    38664404  { 
    38674405    var sel = null; 
     
    38704408    var cmd = null; 
    38714409    var value = null; 
    3872     switch (key) { 
    3873         case 'a': 
    3874       if (!HTMLArea.is_ie) { 
    3875         // KEY select all 
    3876         sel = this._getSelection(); 
    3877         sel.removeAllRanges(); 
    3878         range = this._createRange(); 
    3879         range.selectNodeContents(this._doc.body); 
    3880         sel.addRange(range); 
    3881         HTMLArea._stopEvent(ev); 
    3882       } 
     4410    switch (key) 
     4411    { 
     4412      case 'a': 
     4413        if ( !HTMLArea.is_ie ) 
     4414        { 
     4415          // KEY select all 
     4416          sel = this._getSelection(); 
     4417          sel.removeAllRanges(); 
     4418          range = this._createRange(); 
     4419          range.selectNodeContents(this._doc.body); 
     4420          sel.addRange(range); 
     4421          HTMLArea._stopEvent(ev); 
     4422        } 
    38834423      break; 
    38844424 
    38854425      // simple key commands follow 
    38864426 
    3887         case 'b': cmd = "bold"; break; 
    3888         case 'i': cmd = "italic"; break; 
    3889         case 'u': cmd = "underline"; break; 
    3890         case 's': cmd = "strikethrough"; break; 
    3891         case 'l': cmd = "justifyleft"; break; 
    3892         case 'e': cmd = "justifycenter"; break; 
    3893         case 'r': cmd = "justifyright"; break; 
    3894         case 'j': cmd = "justifyfull"; break; 
    3895         case 'z': cmd = "undo"; break; 
    3896         case 'y': cmd = "redo"; break; 
    3897         case 'v': if (HTMLArea.is_ie || editor.config.htmlareaPaste) { cmd = "paste"; } break; 
    3898         case 'n': cmd = "formatblock"; value = HTMLArea.is_ie ? "<p>" : "p"; break; 
    3899  
    3900         case '0': cmd = "killword"; break; 
     4427      case 'b': cmd = "bold"; break; 
     4428      case 'i': cmd = "italic"; break; 
     4429      case 'u': cmd = "underline"; break; 
     4430      case 's': cmd = "strikethrough"; break; 
     4431      case 'l': cmd = "justifyleft"; break; 
     4432      case 'e': cmd = "justifycenter"; break; 
     4433      case 'r': cmd = "justifyright"; break; 
     4434      case 'j': cmd = "justifyfull"; break; 
     4435      case 'z': cmd = "undo"; break; 
     4436      case 'y': cmd = "redo"; break; 
     4437      case 'v': 
     4438        if ( HTMLArea.is_ie || editor.config.htmlareaPaste ) 
     4439        { 
     4440          cmd = "paste"; 
     4441        } 
     4442      break; 
     4443      case 'n': 
     4444        cmd = "formatblock"; 
     4445        value = HTMLArea.is_ie ? "<p>" : "p"; 
     4446      break; 
     4447 
     4448      case '0': cmd = "killword"; break; 
    39014449 
    39024450      // headings 
    3903         case '1': 
    3904         case '2': 
    3905         case '3': 
    3906         case '4': 
    3907         case '5': 
    3908         case '6': 
    3909       cmd = "formatblock"; 
    3910       value = "h" + key; 
    3911       if (HTMLArea.is_ie) { 
    3912         value = "<" + value + ">"; 
    3913       } 
     4451      case '1': 
     4452      case '2': 
     4453      case '3': 
     4454      case '4': 
     4455      case '5': 
     4456      case '6': 
     4457        cmd = "formatblock"; 
     4458        value = "h" + key; 
     4459        if ( HTMLArea.is_ie ) 
     4460        { 
     4461          value = "<" + value + ">"; 
     4462        } 
    39144463      break; 
    39154464    } 
    3916     if (cmd) { 
     4465    if ( cmd ) 
     4466    { 
    39174467      // execute simple command 
    39184468      this.execCommand(cmd, false, value); 
     
    39204470    } 
    39214471  } 
    3922   else if (keyEvent) 
    3923   { 
    3924  
     4472  else if ( keyEvent ) 
     4473  { 
    39254474    // IE's textRange and selection object is woefully inadequate, 
    39264475    // which means this fancy stuff is gecko only sorry :-| 
    39274476    // Die Bill, Die.  (IE supports it somewhat nativly though) 
    3928     if(HTMLArea.is_gecko) 
     4477    if ( HTMLArea.is_gecko ) 
    39294478    { 
    39304479      var s = editor._getSelection(); 
     
    39324481      { 
    39334482        var rightText = textNode.nextSibling; 
    3934         if(typeof tag == 'string') { tag = editor._doc.createElement(tag); } 
     4483        if ( typeof tag == 'string') 
     4484        { 
     4485          tag = editor._doc.createElement(tag); 
     4486        } 
    39354487        var a = textNode.parentNode.insertBefore(tag, rightText); 
    39364488        HTMLArea.removeFromParent(textNode); 
     
    39384490        rightText.data = ' ' + rightText.data; 
    39394491 
    3940         if(HTMLArea.is_ie) 
     4492        if ( HTMLArea.is_ie ) 
    39414493        { 
    39424494          var r = editor._createRange(s); 
     
    39644516      }; 
    39654517 
    3966       switch(ev.which) 
     4518      switch ( ev.which ) 
    39674519      { 
    39684520        // Space, see if the text just typed looks like a URL, or email address 
    39694521        // and link it appropriatly 
    39704522        case 32: 
    3971           if(s && s.isCollapsed && s.anchorNode.nodeType == 3 && s.anchorNode.data.length > 3 && s.anchorNode.data.indexOf('.') >= 0) 
     4523          if ( s && s.isCollapsed && s.anchorNode.nodeType == 3 && s.anchorNode.data.length > 3 && s.anchorNode.data.indexOf('.') >= 0 ) 
    39724524          { 
    39734525            var midStart = s.anchorNode.data.substring(0,s.anchorOffset).search(/\S{4,}$/); 
    3974             if(midStart == -1) { break; } 
    3975  
    3976             if(this._getFirstAncestor(s, 'a')) 
     4526            if ( midStart == -1 ) 
     4527            { 
     4528              break; 
     4529            } 
     4530 
     4531            if ( this._getFirstAncestor(s, 'a') ) 
    39774532            { 
    39784533              break; // already in an anchor 
     
    39824537 
    39834538            var mEmail = matchData.match(HTMLArea.RE_email); 
    3984             if(mEmail) 
     4539            if ( mEmail ) 
    39854540            { 
    39864541              var leftTextEmail  = s.anchorNode; 
     
    39934548 
    39944549            var mUrl = matchData.match(HTMLArea.RE_url); 
    3995             if(mUrl) 
     4550            if ( mUrl ) 
    39964551            { 
    39974552              var leftTextUrl  = s.anchorNode; 
     
    40044559        break; 
    40054560 
    4006         default : 
    4007           if(ev.keyCode == 27 || (this._unlinkOnUndo && ev.ctrlKey && ev.which == 122) ) 
     4561        default: 
     4562          if ( ev.keyCode == 27 || ( this._unlinkOnUndo && ev.ctrlKey && ev.which == 122 ) ) 
    40084563          { 
    4009             if(this._unLink) 
     4564            if ( this._unLink ) 
    40104565            { 
    40114566              this._unLink(); 
     
    40144569            break; 
    40154570          } 
    4016           else if(ev.which || ev.keyCode == 8 || ev.keyCode == 46) 
     4571          else if ( ev.which || ev.keyCode == 8 || ev.keyCode == 46 ) 
    40174572          { 
    40184573            this._unlinkOnUndo = false; 
    40194574 
    4020             if(s.anchorNode && s.anchorNode.nodeType == 3) 
     4575            if ( s.anchorNode && s.anchorNode.nodeType == 3 ) 
    40214576            { 
    40224577              // See if we might be changing a link 
    40234578              var a = this._getFirstAncestor(s, 'a'); 
    40244579              // @todo: we probably need here to inform the setTimeout below that we not changing a link and not start another setTimeout 
    4025               if(!a) { break; } // not an anchor 
    4026               if(!a._updateAnchTimeout) 
     4580              if ( !a ) 
    40274581              { 
    4028                 if(   s.anchorNode.data.match(HTMLArea.RE_email) 
    4029                    && (a.href.match('mailto:' + s.anchorNode.data.trim())) 
    4030                   ) 
     4582                break; // not an anchor 
     4583              }  
     4584              if ( !a._updateAnchTimeout ) 
     4585              { 
     4586                if ( s.anchorNode.data.match(HTMLArea.RE_email) && a.href.match('mailto:' + s.anchorNode.data.trim()) ) 
    40314587                { 
    40324588                  var textNode = s.anchorNode; 
    40334589                  var fnAnchor = function() 
    4034                     { 
    4035                       a.href = 'mailto:' + textNode.data.trim(); 
    4036                       // @fixme: why the hell do another timeout is started ? 
    4037                       //         This lead to never ending timer if we dont remove this line 
    4038                       //         But when removed, the email is not correctly updated 
    4039                       a._updateAnchTimeout = setTimeout(fnAnchor, 250); 
    4040                     }; 
     4590                  { 
     4591                    a.href = 'mailto:' + textNode.data.trim(); 
     4592                    // @fixme: why the hell do another timeout is started ? 
     4593                    //         This lead to never ending timer if we dont remove this line 
     4594                    //         But when removed, the email is not correctly updated 
     4595                    a._updateAnchTimeout = setTimeout(fnAnchor, 250); 
     4596                  }; 
    40414597                  a._updateAnchTimeout = setTimeout(fnAnchor, 1000); 
    40424598                  break; 
     
    40444600 
    40454601                var m = s.anchorNode.data.match(HTMLArea.RE_url); 
    4046                 if(m && a.href.match(s.anchorNode.data.trim()) ) 
     4602                if ( m && a.href.match(s.anchorNode.data.trim()) ) 
    40474603                { 
    40484604                  var txtNode = s.anchorNode; 
    40494605                  var fnUrl = function() 
    4050                     { 
    4051                       // @fixme: Alert, sometimes m is undefined becase the url is not an url anymore (was www.url.com and become for example www.url) 
    4052                       var m = txtNode.data.match(HTMLArea.RE_url); 
    4053                       a.href = (m[1] ? m[1] : 'http://') + m[2]; 
    4054                       // @fixme: why the hell do another timeout is started ? 
    4055                       //         This lead to never ending timer if we dont remove this line 
    4056                       //         But when removed, the url is not correctly updated 
    4057                       a._updateAnchTimeout = setTimeout(fnUrl, 250); 
    4058                     }; 
     4606                  { 
     4607                    // @fixme: Alert, sometimes m is undefined becase the url is not an url anymore (was www.url.com and become for example www.url) 
     4608                    var m = txtNode.data.match(HTMLArea.RE_url); 
     4609                    a.href = (m[1] ? m[1] : 'http://') + m[2]; 
     4610                    // @fixme: why the hell do another timeout is started ? 
     4611                    //         This lead to never ending timer if we dont remove this line 
     4612                    //         But when removed, the url is not correctly updated 
     4613                    a._updateAnchTimeout = setTimeout(fnUrl, 250); 
     4614                  }; 
    40594615                  a._updateAnchTimeout = setTimeout(fnUrl, 1000); 
    40604616                } 
     
    40694625    switch (ev.keyCode) 
    40704626    { 
    4071         case 13: // KEY enter 
    4072       if (HTMLArea.is_gecko && !ev.shiftKey && this.config.mozParaHandler == 'dirty' ) 
    4073       { 
    4074         this.dom_checkInsertP(); 
    4075         HTMLArea._stopEvent(ev); 
    4076       } 
     4627      case 13: // KEY enter 
     4628        if ( HTMLArea.is_gecko && !ev.shiftKey && this.config.mozParaHandler == 'dirty' ) 
     4629        { 
     4630          this.dom_checkInsertP(); 
     4631          HTMLArea._stopEvent(ev); 
     4632        } 
    40774633      break; 
    4078         case 8: // KEY backspace 
    4079         case 46: // KEY delete 
    4080       if ((HTMLArea.is_gecko && !ev.shiftKey) || HTMLArea.is_ie) 
    4081       { 
    4082         if (this.checkBackspace()) 
    4083         { 
    4084           HTMLArea._stopEvent(ev); 
    4085         } 
    4086       } 
     4634      case 8: // KEY backspace 
     4635      case 46: // KEY delete 
     4636        if ( ( HTMLArea.is_gecko && !ev.shiftKey ) || HTMLArea.is_ie ) 
     4637        { 
     4638          if ( this.checkBackspace() ) 
     4639          { 
     4640            HTMLArea._stopEvent(ev); 
     4641          } 
     4642        } 
    40874643      break; 
    40884644    } 
     
    40904646 
    40914647  // update the toolbar state after some time 
    4092   if (editor._timerToolbar) { 
     4648  if ( editor._timerToolbar ) 
     4649  { 
    40934650    clearTimeout(editor._timerToolbar); 
    40944651  } 
    4095   editor._timerToolbar = setTimeout(function() { 
    4096     editor.updateToolbar(); 
    4097     editor._timerToolbar = null; 
    4098   }, 250); 
    4099 }; 
    4100  
    4101 HTMLArea.prototype.convertNode = function(el, newTagName) { 
     4652  editor._timerToolbar = setTimeout( 
     4653    function() 
     4654    { 
     4655      editor.updateToolbar(); 
     4656      editor._timerToolbar = null; 
     4657    }, 
     4658    250); 
     4659}; 
     4660 
     4661HTMLArea.prototype.convertNode = function(el, newTagName) 
     4662{ 
    41024663  var newel = this._doc.createElement(newTagName); 
    4103   while (el.firstChild) { 
     4664  while ( el.firstChild ) 
     4665  { 
    41044666    newel.appendChild(el.firstChild); 
    41054667  } 
     
    41074669}; 
    41084670 
    4109 if(HTMLArea.is_ie) 
     4671if ( HTMLArea.is_ie ) 
    41104672{ 
    41114673  // this function is for IE 
     
    41134675  { 
    41144676    var sel = this._getSelection(); 
    4115     if(sel.type == 'Control') 
     4677    if ( sel.type == 'Control' ) 
    41164678    { 
    41174679      var elm = this._activeElement(sel); 
     
    41294691    r2.moveStart("character", -1); 
    41304692    var a = r2.parentElement(); 
    4131     if (a != range.parentElement() && (/^a$/i.test(a.tagName)) ) 
     4693    // @fixme: why using again a regex to test a single string ??? 
     4694    if ( a != range.parentElement() && ( /^a$/i.test(a.tagName) ) ) 
    41324695    { 
    41334696      r2.collapse(true); 
     
    41454708  { 
    41464709    var self = this; 
    4147     setTimeout(function() 
     4710    setTimeout( 
     4711      function() 
    41484712      { 
    41494713        var sel = self._getSelection(); 
     
    41544718        var EO = range.endOffset; 
    41554719        var newr = SC.nextSibling; 
    4156         if (SC.nodeType == 3) 
     4720        if ( SC.nodeType == 3 ) 
    41574721        { 
    41584722          SC = SC.parentNode; 
    41594723        } 
    4160         if (!(/\S/.test(SC.tagName))) 
     4724        if ( ! ( /\S/.test(SC.tagName) ) ) 
    41614725        { 
    41624726          var p = document.createElement("p"); 
    4163           while (SC.firstChild) 
     4727          while ( SC.firstChild ) 
    41644728          { 
    41654729            p.appendChild(SC.firstChild); 
     
    41744738          sel.addRange(r); 
    41754739        } 
    4176       }, 10); 
     4740      }, 
     4741      10); 
    41774742  }; 
    41784743} 
     
    41954760 */ 
    41964761 
    4197 HTMLArea.prototype.dom_checkInsertP = function() { 
     4762HTMLArea.prototype.dom_checkInsertP = function() 
     4763{ 
    41984764  var p, body; 
    41994765  // Get the insertion point, we'll scrub any highlighted text the user wants rid of while we are there. 
    42004766  var sel = this._getSelection(); 
    42014767  var range = this._createRange(sel); 
    4202   if (!range.collapsed) 
     4768  if ( !range.collapsed ) 
    42034769  { 
    42044770    range.deleteContents(); 
     
    42164782  // document, then insert a space character that we will wrap into a paragraph 
    42174783  // in a bit. 
    4218   if (SC == EC && SC == body && !SO && !EO) 
     4784  if ( SC == EC && SC == body && !SO && !EO ) 
    42194785  { 
    42204786    p = this._doc.createTextNode(" "); 
     
    42324798  var block = null; 
    42334799  body = this._doc.body; 
    4234   for (var i = 0; i < p.length; ++i) 
    4235   { 
    4236     if(HTMLArea.isParaContainer(p[i])) 
     4800  for ( var i = 0; i < p.length; ++i ) 
     4801  { 
     4802    if ( HTMLArea.isParaContainer(p[i]) ) 
    42374803    { 
    42384804      break; 
    42394805    } 
    4240     else if (HTMLArea.isBlockElement(p[i]) && !(/body|html/i.test(p[i].tagName))) 
     4806    else if ( HTMLArea.isBlockElement(p[i]) && ! ( /body|html/i.test(p[i].tagName) ) ) 
    42414807    { 
    42424808      block = p[i]; 
     
    42464812 
    42474813  // If not in a block element, we'll have to turn some stuff into a paragraph 
    4248   if (!block) 
     4814  if ( !block ) 
    42494815  { 
    42504816    // We want to wrap as much stuff as possible into the paragraph in both directions 
     
    42524818    // node just before any of the paragraph containers. 
    42534819    var wrap = range.startContainer; 
    4254     while(wrap.parentNode && !HTMLArea.isParaContainer(wrap.parentNode)) 
     4820    while ( wrap.parentNode && !HTMLArea.isParaContainer(wrap.parentNode) ) 
    42554821    { 
    42564822      wrap = wrap.parentNode; 
     
    42614827    // Now we walk up the sibling list until we hit the top of the document 
    42624828    // or an element that we shouldn't put in a p (eg other p, div, ul, ol, table) 
    4263     while(start.previousSibling) 
    4264     { 
    4265       if(start.previousSibling.tagName) 
    4266       { 
    4267         if(!HTMLArea.isBlockElement(start.previousSibling)) 
     4829    while ( start.previousSibling ) 
     4830    { 
     4831      if ( start.previousSibling.tagName ) 
     4832      { 
     4833        if ( !HTMLArea.isBlockElement(start.previousSibling) ) 
    42684834        { 
    42694835          start = start.previousSibling; 
     
    42814847 
    42824848    // Same down the list 
    4283     while(end.nextSibling) 
    4284     { 
    4285       if(end.nextSibling.tagName) 
    4286       { 
    4287         if(!HTMLArea.isBlockElement(end.nextSibling)) 
     4849    while ( end.nextSibling ) 
     4850    { 
     4851      if ( end.nextSibling.tagName ) 
     4852      { 
     4853        if ( !HTMLArea.isBlockElement(end.nextSibling) ) 
    42884854        { 
    42894855          end = end.nextSibling; 
     
    43264892  var df = r2.extractContents(); 
    43274893 
    4328   if(df.childNodes.length === 0) 
     4894  if ( df.childNodes.length === 0 ) 
    43294895  { 
    43304896    df.appendChild(this._doc.createElement('p')); 
     
    43324898  } 
    43334899 
    4334   if(df.childNodes.length > 1) 
     4900  if ( df.childNodes.length > 1 ) 
    43354901  { 
    43364902    var nb = this._doc.createElement('p'); 
    4337     while(df.firstChild) 
     4903    while ( df.firstChild ) 
    43384904    { 
    43394905      var s = df.firstChild; 
     
    43454911 
    43464912  // If the original block is empty, put a &nsbp; in it. 
    4347   if (!(/\S/.test(block.innerHTML))) { 
     4913  // @fixme: why using a regex instead of : if (block.innerHTML.trim() == '') ? 
     4914  if ( ! ( /\S/.test(block.innerHTML) ) ) 
     4915  { 
    43484916    block.innerHTML = "&nbsp;"; 
    43494917  } 
    43504918 
    43514919  p = df.firstChild; 
    4352   if (!(/\S/.test(p.innerHTML))) 
     4920  // @fixme: why using a regex instead of : if (p.innerHTML.trim() == '') ? 
     4921  if ( ! ( /\S/.test(p.innerHTML) ) ) 
    43534922  { 
    43544923    p.innerHTML = "<br />"; 
     
    43574926  // If the new block is empty and it's a heading, make it a paragraph 
    43584927  // note, the new block is empty when you are hitting enter at the end of the existing block 
    4359   if ((/^\s*<br\s*\/?>\s*$/.test(p.innerHTML)) && (/^h[1-6]$/i.test(p.tagName))) 
     4928  if ( ( /^\s*<br\s*\/?>\s*$/.test(p.innerHTML) ) && ( /^h[1-6]$/i.test(p.tagName) ) ) 
    43604929  { 
    43614930    df.appendChild(this.convertNode(p, "p")); 
     
    43874956HTMLArea.prototype.scrollToElement = function(e) 
    43884957{ 
    4389   if(HTMLArea.is_gecko) 
     4958  if ( HTMLArea.is_gecko ) 
    43904959  { 
    43914960    var top  = 0; 
    43924961    var left = 0; 
    4393     while(e) 
     4962    while ( e ) 
    43944963    { 
    43954964      top  += e.offsetTop; 
    43964965      left += e.offsetLeft; 
    4397       if(e.offsetParent && e.offsetParent.tagName.toLowerCase() != 'body') 
     4966      if ( e.offsetParent && e.offsetParent.tagName.toLowerCase() != 'body' ) 
    43984967      { 
    43994968        e = e.offsetParent; 
     
    44094978 
    44104979// retrieve the HTML 
    4411 HTMLArea.prototype.getHTML = function() { 
     4980HTMLArea.prototype.getHTML = function() 
     4981{ 
    44124982  var html = ''; 
    4413   switch (this._editMode) { 
    4414       case "wysiwyg"  : 
    4415           if (!this.config.fullPage) { 
    4416             html = HTMLArea.getHTML(this._doc.body, false, this); 
    4417           } else { 
    4418             html = this.doctype + "\n" + HTMLArea.getHTML(this._doc.documentElement, true, this); 
    4419           } 
    4420           break; 
    4421       case "textmode" : 
    4422           html = this._textArea.value; 
    4423           break; 
    4424       default           : 
    4425           alert("Mode <" + this._editMode + "> not defined!"); 
    4426           return false; 
     4983  switch ( this._editMode ) 
     4984  { 
     4985    case "wysiwyg": 
     4986      if ( !this.config.fullPage ) 
     4987      { 
     4988        html = HTMLArea.getHTML(this._doc.body, false, this); 
     4989      } 
     4990      else 
     4991      { 
     4992        html = this.doctype + "\n" + HTMLArea.getHTML(this._doc.documentElement, true, this); 
     4993      } 
     4994    break; 
     4995    case "textmode": 
     4996      html = this._textArea.value; 
     4997    break; 
     4998    default: 
     4999      alert("Mode <" + this._editMode + "> not defined!"); 
     5000      return false; 
    44275001  } 
    44285002  return html; 
     
    44535027  html = this.fixRelativeLinks(html); 
    44545028 
    4455   if(this.config.sevenBitClean) 
    4456   { 
    4457     html = html.replace(/[^ -~\r\n\t]/g, function(c){ return '&#'+c.charCodeAt(0)+';';}); 
     5029  if ( this.config.sevenBitClean ) 
     5030  { 
     5031    html = html.replace(/[^ -~\r\n\t]/g, function(c) { return '&#'+c.charCodeAt(0)+';'; }); 
    44585032  } 
    44595033 
     
    44615035  // so we strip it out.  Original submitter gave a plugin, but that's 
    44625036  // a bit much just for this IMHO - james 
    4463   if(HTMLArea.is_gecko) 
     5037  if ( HTMLArea.is_gecko ) 
    44645038  { 
    44655039    html = html.replace(/<script[\s]*src[\s]*=[\s]*['"]chrome:\/\/.*?["']>[\s]*<\/script>/ig, ''); 
     
    44735047  // Midas uses b and i instead of strong and em, um, hello, 
    44745048  // mozilla, this is the 21st century calling! 
    4475   if (HTMLArea.is_gecko) { 
     5049  if ( HTMLArea.is_gecko ) 
     5050  { 
    44765051    html = html.replace(/<(\/?)strong(\s|>|\/)/ig, "<$1b$2"); 
    44775052    html = html.replace(/<(\/?)em(\s|>|\/)/ig, "<$1i$2");     
     
    44805055  // Both IE and Gecko use strike instead of del (#523) 
    44815056  html = html.replace(/<(\/?)del(\s|>|\/)/ig, "<$1strike$2"); 
    4482   
    44835057 
    44845058  // replace window.open to that any clicks won't open a popup in designMode 
     
    44985072HTMLArea.prototype.outwardSpecialReplacements = function(html) 
    44995073{ 
    4500   for(var i in this.config.specialReplacements) 
     5074  for ( var i in this.config.specialReplacements ) 
    45015075  { 
    45025076    var from = this.config.specialReplacements[i]; 
    45035077    var to   = i; // why are declaring a new variable here ? Seems to be better to just do : for (var to in config) 
    4504     if (typeof(from.replace) != 'function' || typeof(to.replace) != 'function') { continue; } // prevent iterating over wrong type 
     5078    // prevent iterating over wrong type 
     5079    if ( typeof from.replace != 'function' || typeof to.replace != 'function' ) 
     5080    { 
     5081      continue; 
     5082    }  
    45055083    // alert('out : ' + from + '=>' + to); 
    45065084    var reg = new RegExp(from.replace(HTMLArea.RE_Specials, '\\$1'), 'g'); 
     
    45145092{ 
    45155093  // alert("inward"); 
    4516   for(var i in this.config.specialReplacements) 
     5094  for ( var i in this.config.specialReplacements ) 
    45175095  { 
    45185096    var from = i; // why are declaring a new variable here ? Seems to be better to just do : for (var from in config) 
    45195097    var to   = this.config.specialReplacements[i]; 
    4520  
    4521     if (typeof(from.replace) != 'function' || typeof(to.replace) != 'function') { continue; } // prevent iterating over wrong type 
     5098    // prevent iterating over wrong type 
     5099    if ( typeof from.replace != 'function' || typeof to.replace != 'function' ) 
     5100    { 
     5101      continue; 
     5102    } 
    45225103    // alert('in : ' + from + '=>' + to); 
    45235104    // 
     
    45335114HTMLArea.prototype.fixRelativeLinks = function(html) 
    45345115{ 
    4535  
    4536   if(typeof this.config.stripSelfNamedAnchors != 'undefined' && this.config.stripSelfNamedAnchors) 
     5116  if ( typeof this.config.stripSelfNamedAnchors != 'undefined' && this.config.stripSelfNamedAnchors ) 
    45375117  { 
    45385118    var stripRe = new RegExp(document.location.href.replace(HTMLArea.RE_Specials, '\\$1') + '(#[^\'" ]*)', 'g'); 
     
    45405120  } 
    45415121 
    4542  
    4543   if(typeof this.config.stripBaseHref != 'undefined' && this.config.stripBaseHref) 
     5122  if ( typeof this.config.stripBaseHref != 'undefined' && this.config.stripBaseHref ) 
    45445123  { 
    45455124    var baseRe = null; 
    4546     if(typeof this.config.baseHref != 'undefined' && this.config.baseHref !== null) 
     5125    if ( typeof this.config.baseHref != 'undefined' && this.config.baseHref !== null ) 
    45475126    { 
    45485127      baseRe = new RegExp(this.config.baseHref.replace(HTMLArea.RE_Specials, '\\$1'), 'g'); 
     
    45565135  } 
    45575136 
    4558   if(HTMLArea.is_ie) 
    4559   { 
     5137//  if ( HTMLArea.is_ie ) 
     5138//  { 
    45605139    // This is now done in inward & outward 
    45615140    // Don't know why but IE is doing this (putting http://null/ on links?! 
     
    45645143    // html = html.replace(nullRE, location.href.replace(/(https?:\/\/[^\/]*\/).*/, '$1')); 
    45655144    // alert(html); 
    4566   } 
     5145//  } 
    45675146 
    45685147  return html; 
     
    45705149 
    45715150// retrieve the HTML (fastest version, but uses innerHTML) 
    4572 HTMLArea.prototype.getInnerHTML = function() { 
    4573   if(!this._doc.body) { return ''; } 
     5151HTMLArea.prototype.getInnerHTML = function() 
     5152{ 
     5153  if ( !this._doc.body ) 
     5154  { 
     5155    return ''; 
     5156  } 
    45745157  var html = ""; 
    4575   switch (this._editMode) { 
    4576       case "wysiwyg"  : 
    4577         if (!this.config.fullPage) { 
    4578           // return this._doc.body.innerHTML; 
    4579           html = this._doc.body.innerHTML; 
    4580         } else { 
    4581           html = this.doctype + "\n" + this._doc.documentElement.innerHTML; 
    4582         } 
    4583         break; 
    4584       case "textmode" : 
    4585         html = this._textArea.value; 
    4586         break; 
    4587       default       : 
    4588         alert("Mode <" + this._editMode + "> not defined!"); 
    4589         return false; 
     5158  switch ( this._editMode ) 
     5159  { 
     5160    case "wysiwyg": 
     5161      if ( !this.config.fullPage ) 
     5162      { 
     5163        // return this._doc.body.innerHTML; 
     5164        html = this._doc.body.innerHTML; 
     5165      } 
     5166      else 
     5167      { 
     5168        html = this.doctype + "\n" + this._doc.documentElement.innerHTML; 
     5169      } 
     5170    break; 
     5171    case "textmode" : 
     5172      html = this._textArea.value; 
     5173    break; 
     5174    default: 
     5175      alert("Mode <" + this._editMode + "> not defined!"); 
     5176      return false; 
    45905177  } 
    45915178 
     
    45945181 
    45955182// completely change the HTML inside 
    4596 HTMLArea.prototype.setHTML = function(html) { 
    4597   if (!this.config.fullPage) 
     5183HTMLArea.prototype.setHTML = function(html) 
     5184{ 
     5185  if ( !this.config.fullPage ) 
    45985186  { 
    45995187    this._doc.body.innerHTML = html; 
     
    46075195 
    46085196// sets the given doctype (useful when config.fullPage is true) 
    4609 HTMLArea.prototype.setDoctype = function(doctype) { 
     5197HTMLArea.prototype.setDoctype = function(doctype) 
     5198{ 
    46105199  this.doctype = doctype; 
    46115200}; 
     
    46195208 
    46205209// function that returns a clone of the given object 
    4621 HTMLArea.cloneObject = function(obj) { 
    4622   if (!obj) { return null; } 
     5210HTMLArea.cloneObject = function(obj) 
     5211{ 
     5212  if ( !obj ) 
     5213  { 
     5214    return null; 
     5215  } 
     5216 
    46235217  var newObj = {}; 
    46245218 
    46255219  // check for array objects 
    4626   if (obj.constructor.toString().match( /\s*function Array\(/ )) { 
     5220  if ( obj.constructor.toString().match( /\s*function Array\(/ ) ) 
     5221  { 
    46275222    newObj = obj.constructor(); 
    46285223  } 
    46295224 
    46305225  // check for function objects (as usual, IE is fucked up) 
    4631   if (obj.constructor.toString().match( /\s*function Function\(/ )) { 
     5226  if ( obj.constructor.toString().match( /\s*function Function\(/ ) ) 
     5227  { 
    46325228    newObj = obj; // just copy reference to it 
    4633   } else { 
    4634     for (var n in obj) { 
     5229  } 
     5230  else 
     5231  { 
     5232    for ( var n in obj ) 
     5233    { 
    46355234      var node = obj[n]; 
    4636       if (typeof node == 'object') { newObj[n] = HTMLArea.cloneObject(node); } 
    4637       else                         { newObj[n] = node; } 
     5235      if ( typeof node == 'object' ) 
     5236      { 
     5237        newObj[n] = HTMLArea.cloneObject(node); 
     5238      } 
     5239      else 
     5240      { 
     5241        newObj[n] = node; 
     5242      } 
    46385243    } 
    46395244  } 
     
    46435248 
    46445249// FIXME!!! this should return false for IE < 5.5 
    4645 HTMLArea.checkSupportedBrowser = function() { 
    4646   if (HTMLArea.is_gecko) { 
    4647     if (navigator.productSub < 20021201) { 
    4648       alert("You need at least Mozilla-1.3 Alpha.\n" + 
    4649             "Sorry, your Gecko is not supported."); 
     5250HTMLArea.checkSupportedBrowser = function() 
     5251{ 
     5252  if ( HTMLArea.is_gecko ) 
     5253  { 
     5254    if ( navigator.productSub < 20021201 ) 
     5255    { 
     5256      alert("You need at least Mozilla-1.3 Alpha.\nSorry, your Gecko is not supported."); 
    46505257      return false; 
    46515258    } 
    4652     if (navigator.productSub < 20030210) { 
    4653       alert("Mozilla < 1.3 Beta is not supported!\n" + 
    4654             "I'll try, though, but it might not work."); 
     5259    if ( navigator.productSub < 20030210 ) 
     5260    { 
     5261      alert("Mozilla < 1.3 Beta is not supported!\nI'll try, though, but it might not work."); 
    46555262    } 
    46565263  } 
     
    46615268 
    46625269// returns the current selection object 
    4663 if (HTMLArea.is_ie) 
     5270if ( HTMLArea.is_ie ) 
    46645271{ 
    46655272  HTMLArea.prototype._getSelection = function() 
     
    46775284 
    46785285// returns a range for the current selection 
    4679 if (HTMLArea.is_ie) 
     5286if ( HTMLArea.is_ie ) 
    46805287{ 
    46815288  HTMLArea.prototype._createRange = function(sel) 
     
    46895296  { 
    46905297    this.activateEditor(); 
    4691     if (typeof sel != "undefined") 
     5298    if ( typeof sel != "undefined" ) 
    46925299    { 
    46935300      try 
     
    46955302        return sel.getRangeAt(0); 
    46965303      } 
    4697       catch(e) 
     5304      catch(ex) 
    46985305      { 
    46995306        return this._doc.createRange(); 
     
    47155322 *  through _addEvent(s)) and clear any DOM-0 events. 
    47165323 */ 
    4717 HTMLArea._eventFlushers = [ ]; 
     5324HTMLArea._eventFlushers = []; 
    47185325HTMLArea.flushEvents = function() 
    47195326{ 
     
    47215328  // @todo : check if Array.prototype.pop exists for every supported browsers 
    47225329  var e = HTMLArea._eventFlushers.pop(); 
    4723   while(e) 
     5330  while ( e ) 
    47245331  { 
    47255332    try 
    47265333    { 
    4727       if(e.length == 3) 
     5334      if ( e.length == 3 ) 
    47285335      { 
    47295336        HTMLArea._removeEvent(e[0], e[1], e[2]); 
    47305337        x++; 
    47315338      } 
    4732       else if (e.length == 2) 
     5339      else if ( e.length == 2 ) 
    47335340      { 
    47345341        e[0]['on' + e[1]] = null; 
     
    47665373}; 
    47675374 
    4768 if (document.addEventListener) 
     5375if ( document.addEventListener ) 
    47695376{ 
    47705377  HTMLArea._addEvent = function(el, evname, func) 
     
    47835390  }; 
    47845391} 
    4785 else if (document.attachEvent) 
     5392else if ( document.attachEvent