Changeset 539


Ignore:
Timestamp:
08/04/06 15:41:08 (8 years ago)
Author:
mokhet
Message:

apply patch with proper variable name from ticket #658

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/mokhet/htmlarea.js

    r536 r539  
    10771077        el.appendChild(op); 
    10781078      } 
    1079       HTMLArea._addEvent(el, "change", function () { editor._comboSelected(el, txt); } ); 
     1079      HTMLArea.Events.add(el, 'change', HTMLArea.onchange_toolbar_select, editor, [el,txt]); 
    10801080    } 
    10811081    return el; 
     
    11581158 
    11591159      // handlers to emulate nice flat toolbar buttons 
    1160       HTMLArea._addEvent( 
    1161         el, 
    1162         "mouseout", 
    1163         function(ev) 
    1164         { 
    1165           if ( obj.enabled ) 
    1166           { 
    1167             //HTMLArea._removeClass(el, "buttonHover"); 
    1168             HTMLArea._removeClass(el, "buttonActive"); 
    1169             if ( obj.active ) 
    1170             { 
    1171               HTMLArea._addClass(el, "buttonPressed"); 
    1172             } 
    1173           } 
    1174         } 
    1175       ); 
    1176  
    1177       HTMLArea._addEvent( 
    1178         el, 
    1179         "mousedown", 
    1180         function(ev) 
    1181         { 
    1182           if ( obj.enabled ) 
    1183           { 
    1184             HTMLArea._addClass(el, "buttonActive"); 
    1185             HTMLArea._removeClass(el, "buttonPressed"); 
    1186             HTMLArea._stopEvent(HTMLArea.is_ie ? window.event : ev); 
    1187           } 
    1188         } 
    1189       ); 
     1160      HTMLArea.Events.add(el, 'mouseout', HTMLArea.onmouseout_toolbar_button, el, obj); 
     1161 
     1162      HTMLArea.Events.add(el, 'mousedown', HTMLArea.onmousedown_toolbar_button, el, obj); 
    11901163 
    11911164      // when clicked, do the following: 
    1192       HTMLArea._addEvent( 
    1193         el, 
    1194         "click", 
    1195         function(ev) 
    1196         { 
    1197           if ( obj.enabled ) 
    1198           { 
    1199             HTMLArea._removeClass(el, "buttonActive"); 
    1200             //HTMLArea._removeClass(el, "buttonHover"); 
    1201             if ( HTMLArea.is_gecko ) 
    1202             { 
    1203               editor.activateEditor(); 
    1204             } 
    1205             obj.cmd(editor, obj.name, obj); 
    1206             HTMLArea._stopEvent(HTMLArea.is_ie ? window.event : ev); 
    1207           } 
    1208         } 
    1209       ); 
     1165      HTMLArea.Events.add(el, 'click', HTMLArea.onclick_toolbar_button, editor, [el, obj]); 
    12101166 
    12111167      var i_contain = HTMLArea.makeBtnImg(btn[1]); 
     
    15961552  { 
    15971553    // onsubmit get the HTMLArea content and update original textarea. 
    1598     HTMLArea.prependDom0Event( 
    1599       this._textArea.form, 
    1600       'submit', 
    1601       function() 
    1602       { 
    1603         editor._textArea.value = editor.outwardHtml(editor.getHTML()); 
    1604         return true; 
    1605       } 
    1606     ); 
    1607  
    1608     var initialTAContent = textarea.value; 
     1554    HTMLArea.Events.add(textarea.form, 'submit', HTMLArea.onsubmit_form, this, textarea, 'prepend'); 
     1555 
     1556//    var initialTAContent = textarea.value; 
    16091557 
    16101558    // onreset revert the HTMLArea content to the textarea content 
    1611     HTMLArea.prependDom0Event( 
    1612       this._textArea.form, 
    1613       'reset', 
    1614       function() 
    1615       { 
    1616         editor.setHTML(editor.inwardHtml(initialTAContent)); 
    1617         editor.updateToolbar(); 
    1618         return true; 
    1619       } 
    1620     ); 
     1559    HTMLArea.Events.add(textarea.form, 'reset', HTMLArea.onreset_form, this, textarea.value, 'prepend'); 
    16211560  } 
    16221561 
    16231562  // add a handler for the "back/forward" case -- on body.unload we save 
    16241563  // the HTML content into the original textarea. 
    1625   HTMLArea.prependDom0Event( 
    1626     window, 
    1627     'unload', 
    1628     function() 
    1629     { 
    1630       textarea.value = editor.outwardHtml(editor.getHTML()); 
    1631       return true; 
    1632     } 
    1633   ); 
     1564  HTMLArea.Events.add(window, 'unload', HTMLArea.onunload_backforward, editor, textarea, 'prepend'); 
    16341565 
    16351566  // Hide textarea 
     
    16411572  // Add an event to initialize the iframe once loaded. 
    16421573  editor._iframeLoadDone = false; 
    1643   HTMLArea._addEvent( 
    1644     this._iframe, 
    1645     'load', 
    1646     function(e) 
    1647     { 
    1648       if ( !editor._iframeLoadDone ) 
    1649       { 
    1650         editor._iframeLoadDone = true; 
    1651         editor.initIframe(); 
    1652       } 
    1653       return true; 
    1654     } 
    1655   ); 
    1656  
     1574  HTMLArea.Events.add(iframe, 'load', HTMLArea.onload_iframe, this); 
     1575 
     1576  return true; 
    16571577}; 
    16581578 
     
    23412261HTMLArea.prototype.setEditorEvents = function() 
    23422262{ 
    2343   var editor=this; 
    2344   var doc=this._doc; 
    2345   editor.whenDocReady( 
     2263  var id = this.__htmlarea_id_num; 
     2264  this.whenDocReady( 
    23462265    function() 
    23472266    { 
     2267      var editor = __htmlareas[id]; 
     2268      var doc = editor._doc; 
    23482269      // if we have multiple editors some bug in Mozilla makes some lose editing ability 
    2349       HTMLArea._addEvents( 
    2350         doc, 
    2351         ["mousedown"], 
    2352         function() 
    2353         { 
    2354           editor.activateEditor(); 
    2355           return true; 
    2356         } 
    2357       ); 
     2270      HTMLArea.Events.add(doc, 'mousedown', editor.activateEditor, editor); 
    23582271 
    23592272      // intercept some events; for updating the toolbar & keyboard handlers 
    2360       HTMLArea._addEvents( 
     2273      HTMLArea.Events.add( 
    23612274        doc, 
    23622275        ["keydown", "keypress", "mousedown", "mouseup", "drag"], 
    2363         function (event) 
    2364         { 
    2365           return editor._editorEvent(HTMLArea.is_ie ? editor._iframe.contentWindow.event : event); 
    2366         } 
     2276        HTMLArea.keymousedrag_doc, 
     2277        editor 
    23672278      ); 
    23682279 
     
    23802291      } 
    23812292 
    2382       HTMLArea.addDom0Event(window, 'resize', function(e) { editor.sizeEditor(); }); 
     2293      // on window resize, resize the editor 
     2294      HTMLArea.Events.add(window, 'resize', editor.sizeEditor, editor); 
    23832295      editor.removeLoadingMessage(); 
    23842296    } 
     
    29652877} 
    29662878 
     2879HTMLArea.prototype._statusElements = []; 
    29672880// FIXME : this function needs to be splitted in more functions. 
    29682881// It is actually to heavy to be understable and very scary to manipulate 
     
    29782891    if ( this.config.statusBar && !noStatus ) 
    29792892    { 
    2980       this._statusBarTree.innerHTML = HTMLArea._lc("Path") + ": "; // clear 
     2893      this.statusBarDispose(); 
    29812894      for ( var i = ancestors.length; --i >= 0; ) 
    29822895      { 
     
    29912904        } 
    29922905        var a = document.createElement("a"); 
    2993         a.href = "javascript:void(0)"; 
    2994         a.el = el; 
    2995         a.editor = this; 
    2996         HTMLArea.addDom0Event( 
    2997           a, 
    2998           'click', 
    2999           function() { 
    3000             this.blur(); 
    3001             this.editor.selectNodeContents(this.el); 
    3002             this.editor.updateToolbar(true); 
    3003             return false; 
    3004           } 
    3005         ); 
    3006         HTMLArea.addDom0Event( 
    3007           a, 
    3008           'contextmenu', 
    3009           function() 
    3010           { 
    3011             // TODO: add context menu here 
    3012             this.blur(); 
    3013             var info = "Inline style:\n\n"; 
    3014             info += this.el.style.cssText.split(/;\s*/).join(";\n"); 
    3015             alert(info); 
    3016             return false; 
    3017           } 
    3018         ); 
     2906        a.href = "#"; 
     2907//        a.el = el; 
     2908//        a.editor = this; 
     2909        HTMLArea.Events.add(a, 'click', HTMLArea.onclick_status_updateToolbar, this, a); 
     2910 
     2911        HTMLArea.Events.add(a, 'contextmenu', HTMLArea.oncontextmenu_status, a, el); 
     2912 
    30192913        var txt = el.tagName.toLowerCase(); 
    30202914        a.title = el.style.cssText; 
     
    30332927          this._statusBarTree.appendChild(document.createTextNode(String.fromCharCode(0xbb))); 
    30342928        } 
     2929        this._statusElements.push(a); 
    30352930      } 
    30362931    } 
     
    32613156}; 
    32623157 
     3158/** 
     3159 * Dispose the elements in the statusbar 
     3160 * @private 
     3161 */ 
     3162HTMLArea.prototype.statusBarDispose = function() 
     3163{ 
     3164  for ( var i = 0, m = this._statusElements.length; i < m; i++ ) 
     3165  { 
     3166    var a = this._statusElements[i]; 
     3167    HTMLArea.Events.remove(a, 'click', HTMLArea.onclick_status_updateToolbar); 
     3168    HTMLArea.Events.remove(a, 'contextmenu', HTMLArea.oncontextmenu_status); 
     3169  } 
     3170  this._statusElements = []; 
     3171  this._statusBarTree.innerHTML = HTMLArea._lc("Path") + ": "; // clear 
     3172}; 
    32633173/** Returns a node after which we can insert other nodes, in the current 
    32643174 * selection.  The selection is removed.  It splits a text node, if needed. 
     
    35313441    // correct, we possibly should do a simlar check to IE? 
    35323442    if ( !sel.isCollapsed ) 
    3533     {       
     3443    { 
    35343444      if ( sel.anchorNode.childNodes.length > sel.anchorOffset && sel.anchorNode.childNodes[sel.anchorOffset].nodeType == 1 ) 
    35353445      { 
     
    35713481 
    35723482    if ( typeof sel.isCollapsed != 'undefined' ) 
    3573     {       
     3483    { 
    35743484      return sel.isCollapsed; 
    35753485    } 
     
    67626672}; 
    67636673 
     6674/* 
     6675--------------------------------------------------------------------------- 
     6676  EVENTS - NEW VERSION 
     6677--------------------------------------------------------------------------- 
     6678*/ 
     6679 
     6680HTMLArea.Events = 
     6681{ 
     6682  /** 
     6683   * Events listeners 
     6684   * @private 
     6685   */ 
     6686  listeners : [], 
     6687   
     6688  /** 
     6689   * DOM0 handlers 
     6690   * @private 
     6691   */ 
     6692  DOM0Handlers : [], 
     6693 
     6694  /** 
     6695   * DOM0 listeners 
     6696   * @private 
     6697   */ 
     6698  DOM0Listeners : [], 
     6699   
     6700  /** 
     6701   * Fix the callback event object especially for IE which provides it in window.event 
     6702   * @param {Event} evt Event (for W3C compliant) and null for IE 
     6703   * @return {Event} Unified event 
     6704   * @private 
     6705   */ 
     6706  fix : function(evt) { return evt || window.event; }, 
     6707 
     6708  /** 
     6709   * Add a listener to an element 
     6710   * @param {string | HTMLElement} element      Element ID or the reference 
     6711   * @param {string | array}       type         Event type to add or indexed array of event types to add 
     6712   * @param {function}             handler      Event handler 
     6713   * @param {object}               scope        Execution scope (optional) default to the element reference 
     6714   * @param {object}               arbitraryObj Arbitrary object provided to the handler (optional) default to null 
     6715   * @param {boolean|string}       forceDom0    true if DOM0 model is forced, 'prepend' if DOM0 model is forced and must be prepended to the existings listeners of the same name (optional) default to false 
     6716   * @return {boolean} true if the binding is successfull 
     6717   * @public 
     6718   */ 
     6719  add : function(element, type, handler, scope, arbitraryObj, forceDom0) 
     6720  { 
     6721    // manage multiple type with an array 
     6722    if ( typeof type !== 'string' && type.length && type.length > 0 ) 
     6723    { 
     6724      var returnValue = true; /* return value */ 
     6725      for ( var j = 0, m = type.length; j < m; j++ ) 
     6726      { 
     6727        returnValue = HTMLArea.Events.add(element, type[j], handler, scope, arbitraryObj, forceDom0) && returnValue; 
     6728      } 
     6729      return returnValue; 
     6730    } 
     6731    // if the element is a string, try to find its reference 
     6732    var Element = typeof element === 'string' ? document.getElementById(element) : element; 
     6733    if ( !Element ) { return false; } 
     6734 
     6735    // determine application scope 
     6736    scope = scope ? scope : Element; 
     6737 
     6738    var wrapped = function(z) { return handler.call(scope, HTMLArea.Events.fix(z), arbitraryObj); }, /* Wrapped function called */ 
     6739        listenerIndex = HTMLArea.Events.listeners.length, /* global listener index */ 
     6740        isDOM0 = false; /* flag the type of event model used */ 
     6741 
     6742    // check if DOM0 must be used 
     6743    if ( forceDom0 || HTMLArea.Events._useDOM0(Element, type) ) 
     6744    { 
     6745      // bind the event to the object with DOM0 model 
     6746      var DOM0Index = HTMLArea.Events._getDOM0Index(Element, type); 
     6747      if ( DOM0Index == -1 ) 
     6748      { 
     6749        DOM0Index = HTMLArea.Events.DOM0Handlers.length; 
     6750        // cache the signature for the DOM0 event 
     6751        // [element, type, alreadySetHandler] 
     6752        HTMLArea.Events.DOM0Handlers[DOM0Index] = [Element, type, Element['on' + type]]; 
     6753        HTMLArea.Events.DOM0Listeners[DOM0Index] = []; 
     6754         
     6755        // set our own handler which will be used to fire every listeners 
     6756        // for this type of event on this element 
     6757        Element['on' + type] = function(evt) { return HTMLArea.Events._fireDOM0.call(Element, HTMLArea.Events.fix(evt), DOM0Index); }; 
     6758      } 
     6759 
     6760      // add a reference to the wrapped listener to 
     6761      // the custom stack of events 
     6762      if ( forceDom0 == 'prepend' && HTMLArea.Events.DOM0Listeners[DOM0Index].length > 0 ) 
     6763      { 
     6764        HTMLArea.Events.DOM0Listeners[DOM0Index].unshift(listenerIndex); 
     6765      } 
     6766      else 
     6767      { 
     6768        HTMLArea.Events.DOM0Listeners[DOM0Index].push(listenerIndex); 
     6769      } 
     6770      isDOM0 = true; 
     6771    } 
     6772    else 
     6773    { 
     6774      HTMLArea.Events.bind(Element, type, wrapped); 
     6775    } 
     6776 
     6777    // cache the listener so we can try to automatically unload 
     6778    HTMLArea.Events.listeners[listenerIndex] = [Element, type, handler, wrapped, scope, arbitraryObj, isDOM0]; 
     6779 
     6780    return true; 
     6781  }, 
     6782 
     6783  /** 
     6784   * Remove an event listener 
     6785   * @param {string | HTMLElement} element  Element ID or the reference 
     6786   * @param {string | array}       type     Event type to remove or indexed array of event types to remove 
     6787   * @param {function}             handler  Event handler 
     6788   * @return {boolean} true if the removing is successfull 
     6789   * @public 
     6790   */ 
     6791  remove : function(element, type, handler) 
     6792  { 
     6793    var returnValue = true; /* return value */ 
     6794    // manage multiple type with an array 
     6795    if ( typeof type !== 'string' && type.length && type.length > 0 ) 
     6796    { 
     6797      for ( var j = 0, m = type.length; j < m; j++ ) 
     6798      { 
     6799        returnValue = HTMLArea.Events.remove(element, type[j], handler) && returnValue; 
     6800      } 
     6801      return returnValue; 
     6802    } 
     6803    // if the element is a string, try to find its reference 
     6804    var Element = typeof element == 'string' ? document.getElementById(element) : element; 
     6805    if ( !Element ) { return false; } 
     6806 
     6807    var listener = null, 
     6808        listenerIndex = HTMLArea.Events._getListenerIndex(Element, type, handler); 
     6809    if ( listenerIndex >= 0 ) 
     6810    { 
     6811      listener = HTMLArea.Events.listeners[listenerIndex]; 
     6812    } 
     6813    if ( !listener ) { return false; } 
     6814 
     6815    // listener is set like this : [Element, type, handler, wrapped, scope, arbitraryObj, isDOM0]; 
     6816 
     6817    // remove DOM0 listeners 
     6818    if ( listener[6] === true ) 
     6819    { 
     6820      returnValue = HTMLArea.Events.removeDOM0(listenerIndex, Element, type); 
     6821    } 
     6822    // remove DOM2 et IE listeners 
     6823    else 
     6824    { 
     6825      try 
     6826      { 
     6827        HTMLArea.Events.unbind(Element, type, listener[3]); 
     6828      } 
     6829      catch(x) 
     6830      { 
     6831        try 
     6832        { 
     6833          throw('Error removing event : "' + type + '"\nExc: ' + x + '\nElt: ' + Element + ( Element.tagName ? Element.tagName : '' ) + '\nHandler : ' + listener[3]); 
     6834        } 
     6835        catch (x) 
     6836        { 
     6837          returnValue = false; 
     6838        } 
     6839      } 
     6840    } 
     6841 
     6842    // removed the wrapped handler 
     6843    delete HTMLArea.Events.listeners[listenerIndex][3]; 
     6844    delete HTMLArea.Events.listeners[listenerIndex][2]; 
     6845    delete HTMLArea.Events.listeners[listenerIndex]; 
     6846 
     6847    return returnValue; 
     6848  }, 
     6849 
     6850  /** 
     6851   * Cancel an event 
     6852   * @param {Event} evt The event to cancel 
     6853   * @public 
     6854   */ 
     6855  stop : function(evt) 
     6856  { 
     6857    HTMLArea.Events.stopPropagation(evt); 
     6858    HTMLArea.Events.preventDefault(evt); 
     6859  }, 
     6860 
     6861  /** 
     6862   * Find the listener position in the listeners cache 
     6863   * listener is set like this : [Element, type, handler, wrapped, scope, arbitraryObj, isDOM0]; 
     6864   * @param {HTMLElement} Element  Element reference 
     6865   * @param {string}      type     Event type to search 
     6866   * @param {function}    handler  Event handler to find 
     6867   * @return {integer} Index in the global listeners array 
     6868   * @private 
     6869  */ 
     6870  _getListenerIndex : function(Element, type, handler) 
     6871  { 
     6872    for ( var i = 0, m = HTMLArea.Events.listeners.length; i < m; i++ ) 
     6873    { 
     6874      var L = HTMLArea.Events.listeners[i]; 
     6875      if ( L && L[0] == Element && L[1] == type && L[2] == handler) 
     6876      { 
     6877        return i; 
     6878      } 
     6879    } 
     6880    return -1; 
     6881  }, 
     6882 
     6883  /* 
     6884  --------------------------------------------------------------------------- 
     6885    DOM0 MODEL 
     6886  --------------------------------------------------------------------------- 
     6887  */ 
     6888 
     6889  /** 
     6890   * Find if the DOM0 must be used instead of DOM2 model 
     6891   * @param {HTMLElement} Element Element reference 
     6892   * @param {string}      type    Event type 
     6893   * @return {boolean} true if DOM0 model must be used 
     6894   * @private 
     6895   */ 
     6896  _useDOM0 : function(Element, type) 
     6897  { 
     6898    return ( ( !Element.addEventListener && !Element.attachEvent ) || ( type == "click" && navigator.userAgent.match(/safari/gi) ) ); 
     6899  }, 
     6900 
     6901  /** 
     6902   * Find index of the DOM0 listener with the couple Element + type 
     6903   * @param {HTMLElement} Element Element reference 
     6904   * @param {string}      type    Event type to search 
     6905   * @return {integer} Index in the DOM0 listeners array 
     6906   * @private 
     6907   */ 
     6908  _getDOM0Index : function(Element, type) 
     6909  { 
     6910    for ( var i = 0, m = HTMLArea.Events.DOM0Handlers.length; i < m; i++ ) 
     6911    { 
     6912      var L = HTMLArea.Events.DOM0Handlers[i]; 
     6913      if ( L && L[0] == Element && L[1] == type ) 
     6914      { 
     6915        return i; 
     6916      } 
     6917    } 
     6918    return -1; 
     6919  }, 
     6920 
     6921  /** 
     6922   * When DOM0 is used, handlers are called from this function to let us fire every listeners 
     6923   * @param {Event}   evt The current event 
     6924   * @param {integer} DOM0Index The index of the DOM0 listener to call 
     6925   * @scope Original HTMLElement 
     6926   * @private 
     6927   */ 
     6928  _fireDOM0 : function(evt, DOM0Index) 
     6929  { 
     6930    var returnValue = true, /* return value */ 
     6931        DOMListeners = HTMLArea.Events.DOM0Listeners[DOM0Index], /* DOM0 listeners */ 
     6932        previousListener = HTMLArea.Events.DOM0Handlers[DOM0Index][2], /* previously set DOM0 listener */ 
     6933        returnListener; /* return value of the listener function */ 
     6934    for ( var i = 0, m = DOMListeners.length; i < m; i++ ) 
     6935    { 
     6936      var indexListener = DOMListeners[i]; /* listeners index */ 
     6937      if ( indexListener ) 
     6938      { 
     6939        var listener = HTMLArea.Events.listeners[indexListener]; /* real listener reference */ 
     6940        if ( listener ) 
     6941        { 
     6942          // listener is set like this : [Element, type, handler, wrapped, scope, arbitraryObj, isDOM0]; 
     6943          // call the wrapped function 
     6944          returnListener = listener[3].call(listener[4], evt, listener[5]); 
     6945          returnListener = typeof returnListener == 'boolean' ? returnListener : true; 
     6946          returnValue = returnValue && returnListener; 
     6947        } 
     6948      } 
     6949    } 
     6950    // if a previous listener was set, call it now 
     6951    if ( typeof previousListener == 'function' ) 
     6952    { 
     6953      returnListener = previousListener.call(this, evt); 
     6954      returnListener = typeof returnListener == 'boolean' ? returnListener : true; 
     6955      returnValue = returnValue && returnListener; 
     6956    } 
     6957    return returnValue; 
     6958  }, 
     6959 
     6960  /** 
     6961   * Remove a DOM0 listener 
     6962   * @param {integer}     index    Index of the global listener removed 
     6963   * @param {HTMLElement} Element  Element reference 
     6964   * @param {string}      type     Event type to remove 
     6965   * @return {boolean} true if the remove was success, false on the contrary 
     6966   * @private 
     6967   */ 
     6968  removeDOM0 : function(index, Element, type) 
     6969  { 
     6970    var DOM0Index = HTMLArea.Events._getDOM0Index(Element, type); 
     6971    if ( DOM0Index !== -1 ) 
     6972    { 
     6973      for ( var j = 0, m = HTMLArea.Events.DOM0Listeners[DOM0Index].length; j < m; j++ ) 
     6974      { 
     6975        if ( HTMLArea.Events.DOM0Listeners[DOM0Index] == index ) 
     6976        { 
     6977          delete HTMLArea.Events.DOM0Listeners[DOM0Index][j]; 
     6978          break; 
     6979        } 
     6980      } 
     6981      // check if anymore valid listeners are defined 
     6982      for ( j = 0, m = HTMLArea.Events.DOM0Listeners[DOM0Index].length; j < m; j++ ) 
     6983      { 
     6984        // there it is another active listener of this type for the element, 
     6985        // since we have removed the needed listener, our job is done and we break here 
     6986        if ( HTMLArea.Events.DOM0Listeners[DOM0Index][j] ) 
     6987        { 
     6988          return true; 
     6989        } 
     6990      } 
     6991      // no break, so there is ZERO remaining listener for this type for the element, 
     6992      // so we remove our handler 
     6993      Element['on' + type] = null; 
     6994      delete HTMLArea.Events.DOM0Handlers[DOM0Index]; 
     6995      delete HTMLArea.Events.DOM0Listeners[DOM0Index]; 
     6996      return true; 
     6997    } 
     6998    return false; 
     6999  }, 
     7000 
     7001  /** 
     7002   * Events Flushing 
     7003   * @private 
     7004   */ 
     7005  flusher : function() 
     7006  { 
     7007    var L, i, m; 
     7008 
     7009    // remove our DOM0 handlers 
     7010    for ( i = 0, m = HTMLArea.Events.DOM0Handlers.length; i < m; i++ ) 
     7011    { 
     7012      L = HTMLArea.Events.DOM0Handlers[i]; 
     7013      if ( L ) 
     7014      { 
     7015        L[0]['on' + L[1]] = null; 
     7016      } 
     7017    } 
     7018 
     7019    // remove remaining events 
     7020    if ( HTMLArea.Events.listeners && HTMLArea.Events.listeners.length > 0 ) 
     7021    { 
     7022      for ( i = 0, m = HTMLArea.Events.listeners.length; i < m; i++ ) 
     7023      { 
     7024        L = HTMLArea.Events.listeners[i]; 
     7025        if ( L ) 
     7026        { 
     7027          HTMLArea.Events.remove(L[0], L[1], L[2]); 
     7028        } 
     7029      } 
     7030    } 
     7031 
     7032    for ( i = __htmlareas.length; i--; ) 
     7033    { 
     7034      // this should be in every Xinha instance disposer method instead of here 
     7035      __htmlareas[i].statusBarDispose(); 
     7036      // we should instead do this 
     7037      //__htmlareas[i].dispose(); 
     7038    } 
     7039 
     7040    // garbage IE 
     7041    HTMLArea.collectGarbageForIE(); 
     7042  } 
     7043 
     7044}; 
     7045 
     7046/* 
     7047--------------------------------------------------------------------------- 
     7048  W3C DOM2 EVENTS MODEL 
     7049--------------------------------------------------------------------------- 
     7050*/ 
     7051 
     7052if ( document.addEventListener ) 
     7053{ 
     7054  /** 
     7055   * Buttons constants 
     7056   * @type hash 
     7057   * @public 
     7058   */ 
     7059  HTMLArea.Events.buttons = { left: 0, right: 2, middle: 1 }; 
     7060 
     7061  /** 
     7062   * Bind the element, the event and the callback function 
     7063   * @param {HTMLElement}   Element  The element reference 
     7064   * @param {String}        type     The event type to bind 
     7065   * @param {Function}      handler (Function) The callback function 
     7066   * @private 
     7067   */ 
     7068  HTMLArea.Events.bind = function(Element, type, handler) { Element.addEventListener(type, handler, false); }; 
     7069 
     7070  /** 
     7071   * Unbind the element, the event and the callback function 
     7072   * @param {HTMLElement}   Element  The element reference 
     7073   * @param {String}        type     The event type to bind 
     7074   * @param {Function}      handler (Function) The callback function 
     7075   * @private 
     7076   */ 
     7077  HTMLArea.Events.unbind = function(Element, type, handler) { Element.removeEventListener(type, handler, false); }; 
     7078 
     7079  /** 
     7080   * Cancel the default behavior from the event 
     7081   * @param {Event} evt Event 
     7082   * @public 
     7083   */ 
     7084  HTMLArea.Events.preventDefault = function(evt) { evt.preventDefault(); }; 
     7085 
     7086  /** 
     7087   * Cancel the event propagation 
     7088   * @param {Event} evt Event 
     7089   * @public 
     7090   */ 
     7091  HTMLArea.Events.stopPropagation = function(evt) { evt.stopPropagation(); }; 
     7092} 
     7093 
     7094/* 
     7095--------------------------------------------------------------------------- 
     7096  IE EVENTS MODEL 
     7097--------------------------------------------------------------------------- 
     7098*/ 
     7099else if ( document.attachEvent ) 
     7100{ 
     7101  HTMLArea.Events.buttons = { left: 1, right: 2, middle: 4 }; 
     7102  HTMLArea.Events.bind = function(Element, type, handler) { Element.attachEvent('on' + type, handler); }; 
     7103  HTMLArea.Events.unbind = function(Element, type, handler) { Element.detachEvent('on' + type, handler); }; 
     7104  HTMLArea.Events.preventDefault = function(evt) { evt = HTMLArea.Events.fix(evt); evt.returnValue = false; }; 
     7105  HTMLArea.Events.stopPropagation = function(evt) { evt = HTMLArea.Events.fix(evt); evt.cancelBubble = true; }; 
     7106} 
     7107 
     7108/* 
     7109--------------------------------------------------------------------------- 
     7110  EVENT CALLBACK LISTENERS 
     7111--------------------------------------------------------------------------- 
     7112*/ 
     7113 
     7114/** 
     7115 * Callback listener for onchange on a selectbox in the icon toolbar 
     7116 * @param {Event} evt The current event 
     7117 * @param {array} arbitraryObject here : {array} [el,txt] 
     7118 * @scope Xinha instance 
     7119 * @private 
     7120 */ 
     7121HTMLArea.onchange_toolbar_select = function(evt, arbitraryObject) 
     7122{ 
     7123  this._comboSelected(arbitraryObject[0], arbitraryObject[1]); 
     7124}; 
     7125 
     7126/** 
     7127 * Callback listener for onmouseout on an icon in the icon toolbar 
     7128 * @param {Event} evt The current event 
     7129 * @param {array} arbitraryObject here : {object} obj 
     7130 * @scope The icon HTMLElement 
     7131 * @private 
     7132 */ 
     7133HTMLArea.onmouseout_toolbar_button = function(evt, arbitraryObject) 
     7134{ 
     7135  if ( arbitraryObject.enabled ) 
     7136  { 
     7137    //HTMLArea._removeClass(this, "buttonHover"); 
     7138    HTMLArea._removeClass(this, "buttonActive"); 
     7139    if ( arbitraryObject.active ) 
     7140    { 
     7141      HTMLArea._addClass(this, "buttonPressed"); 
     7142    } 
     7143  } 
     7144}; 
     7145 
     7146/** 
     7147 * Callback listener for onmousedown on an icon in the icon toolbar 
     7148 * @param {Event} evt The current event 
     7149 * @param {array} arbitraryObject here : {object} obj 
     7150 * @scope The icon HTMLElement 
     7151 * @private 
     7152 */ 
     7153HTMLArea.onmousedown_toolbar_button = function(evt, arbitraryObject) 
     7154{ 
     7155  if ( arbitraryObject.enabled ) 
     7156  { 
     7157    HTMLArea._addClass(this, "buttonActive"); 
     7158    HTMLArea._removeClass(this, "buttonPressed"); 
     7159    HTMLArea.Events.stop(evt); 
     7160  } 
     7161}; 
     7162 
     7163/** 
     7164 * Callback listener for onclick on an icon in the icon toolbar 
     7165 * @param {Event} evt The current event 
     7166 * @param {array} arbitraryObject here : {array} [el,obj] 
     7167 * @scope Xinha instance 
     7168 * @private 
     7169 */ 
     7170HTMLArea.onclick_toolbar_button = function(evt, arbitraryObject) 
     7171{ 
     7172  var el = arbitraryObject[0], 
     7173      obj = arbitraryObject[1]; 
     7174  if ( obj.enabled ) 
     7175  { 
     7176    HTMLArea._removeClass(el, "buttonActive"); 
     7177    //HTMLArea._removeClass(el, "buttonHover"); 
     7178    if ( HTMLArea.is_gecko ) 
     7179    { 
     7180      this.activateEditor(); 
     7181    } 
     7182    obj.cmd(this, obj.name, obj); 
     7183    HTMLArea.Events.stop(evt); 
     7184  } 
     7185}; 
     7186 
     7187/** 
     7188 * Callback listener for onload of the main iframe 
     7189 * @param {Event} evt The current event 
     7190 * @scope Xinha instance 
     7191 * @private 
     7192 */ 
     7193HTMLArea.onload_iframe = function(evt) 
     7194{ 
     7195  if ( !this._iframeLoadDone ) 
     7196  { 
     7197    this._iframeLoadDone = true; 
     7198    this.initIframe(); 
     7199  } 
     7200}; 
     7201 
     7202/** 
     7203 * Generic callback listeners for ["keydown", "keypress", "mousedown", "mouseup", "drag"] of the iframe document 
     7204 * @param {Event} evt The current event, the event in the iframe for IE 
     7205 * @scope Xinha instance 
     7206 * @private 
     7207 */ 
     7208if ( HTMLArea.is_ie ) 
     7209{ 
     7210  HTMLArea.keymousedrag_doc = function(evt) { this._editorEvent(this._iframe.contentWindow.event); }; 
     7211} 
     7212else 
     7213{ 
     7214  HTMLArea.keymousedrag_doc = function(evt) { this._editorEvent(evt); }; 
     7215} 
     7216 
     7217/** 
     7218 * Callback listener for onclick on an element on the statusbar 
     7219 * @param {Event} evt The current event 
     7220 * @param {array} arbitraryObject here : {HTMLElement} the tag A rerefence 
     7221 * @scope Xinha instance 
     7222 * @private 
     7223 */ 
     7224HTMLArea.onclick_status_updateToolbar = function(evt, arbitraryObject) 
     7225{ 
     7226  arbitraryObject.blur(); 
     7227  this.selectNodeContents(arbitraryObject.el); 
     7228  this.updateToolbar(true); 
     7229  HTMLArea.Events.stop(evt); 
     7230}; 
     7231 
     7232/** 
     7233 * Callback listener for oncontextmenu on an element on the statusbar 
     7234 * @param {Event} evt The current event 
     7235 * @param {array} arbitraryObject here : {HTMLElement} the ancestor represented by the tag A 
     7236 * @scope the a tag HTMLElement in the statusbar 
     7237 * @private 
     7238 */ 
     7239HTMLArea.oncontextmenu_status = function(evt, arbitraryObject) 
     7240{ 
     7241  // TODO: add context menu here 
     7242  this.blur(); 
     7243  var info = "Inline style:\n\n" + arbitraryObject.style.cssText.split(/;\s*/).join(";\n"); 
     7244  HTMLArea.Events.stop(evt); 
     7245}; 
     7246 
     7247/** 
     7248 * Callback listener for onsubmit (DOM0 model) on the textarea form 
     7249 * @param {Event} evt The current event 
     7250 * @param {array} arbitraryObject here : {HTMLElement} textarea 
     7251 * @scope Xinha instance 
     7252 * @private 
     7253 */ 
     7254HTMLArea.onsubmit_form = function(evt, arbitraryObject) 
     7255{ 
     7256  arbitraryObject.value = this.outwardHtml(this.getHTML()); 
     7257  return true; 
     7258}; 
     7259 
     7260/** 
     7261 * Callback listener for onreset (DOM0 model) on the textarea form 
     7262 * @param {Event} evt The current event 
     7263 * @param {array} arbitraryObject here : {string} initial textarea value 
     7264 * @scope Xinha instance 
     7265 * @private 
     7266 */ 
     7267HTMLArea.onreset_form = function(evt, arbitraryObject) 
     7268{ 
     7269  this.setHTML(this.inwardHtml(arbitraryObject)); 
     7270  this.updateToolbar(); 
     7271  return true; 
     7272}; 
     7273 
     7274/** 
     7275 * Callback listener for unload (DOM0 model) on the window for the back/forward case 
     7276 * @param {Event} evt The current event 
     7277 * @param {array} arbitraryObject here : {HTMLElement} textarea 
     7278 * @scope Xinha instance 
     7279 * @private 
     7280 */ 
     7281HTMLArea.onunload_backforward = function(evt, arbitraryObject) 
     7282{ 
     7283  arbitraryObject.value = this.outwardHtml(this.getHTML()); 
     7284  return true; 
     7285}; 
     7286 
     7287 
     7288 
     7289/* 
     7290--------------------------------------------------------------------------- 
     7291  FINALIZE 
     7292--------------------------------------------------------------------------- 
     7293*/ 
    67647294HTMLArea.init(); 
    6765 HTMLArea.addDom0Event(window,'unload',HTMLArea.collectGarbageForIE); 
     7295HTMLArea.Events.add(window,'unload',HTMLArea.Events.flusher); 
Note: See TracChangeset for help on using the changeset viewer.