[Sommaire] [Imprimer]

   1  function $() {
   2    var results = [], element;
   3    for (var i = 0; i < arguments.length; i++) {
   4      element = arguments[i];
   5      if (typeof element == 'string')
   6        element = document.getElementById(element);
   7      results.push(Element.extend(element));
   8    }
   9    return results.length < 2 ? results[0] : results;
  10  }
  11  
  12  document.getElementsByClassName = function(className, parentElement) {
  13    var children = ($(parentElement) || document.body).getElementsByTagName('*');
  14    return $A(children).inject([], function(elements, child) {
  15      if (child.className.match(new RegExp("(^|\\s)" + className + "(\\s|$)")))
  16        elements.push(Element.extend(child));
  17      return elements;
  18    });
  19  }
  20  
  21  /*--------------------------------------------------------------------------*/
  22  
  23  if (!window.Element)
  24    var Element = new Object();
  25  
  26  Element.extend = function(element) {
  27    if (!element) return;
  28    if (_nativeExtensions) return element;
  29    
  30    if (!element._extended && element.tagName && element != window) {
  31      var methods = Element.Methods, cache = Element.extend.cache;
  32      for (property in methods) {
  33        var value = methods[property];
  34        if (typeof value == 'function')
  35          element[property] = cache.findOrStore(value);
  36      }
  37    }
  38    
  39    element._extended = true;
  40    return element;
  41  }
  42  
  43  Element.extend.cache = {
  44    findOrStore: function(value) {
  45      return this[value] = this[value] || function() {
  46        return value.apply(null, [this].concat($A(arguments)));
  47      }
  48    }
  49  }
  50  
  51  Element.Methods = {
  52    visible: function(element) {
  53      return $(element).style.display != 'none';
  54    },
  55    
  56    toggle: function() {
  57      for (var i = 0; i < arguments.length; i++) {
  58        var element = $(arguments[i]);
  59        Element[Element.visible(element) ? 'hide' : 'show'](element);
  60      }
  61    },
  62  
  63    hide: function() {
  64      for (var i = 0; i < arguments.length; i++) {
  65        var element = $(arguments[i]);
  66        element.style.display = 'none';
  67      }
  68    },
  69    
  70    show: function() {
  71      for (var i = 0; i < arguments.length; i++) {
  72        var element = $(arguments[i]);
  73        element.style.display = '';
  74      }
  75    },
  76  
  77    remove: function(element) {
  78      element = $(element);
  79      element.parentNode.removeChild(element);
  80    },
  81  
  82    update: function(element, html) {
  83      $(element).innerHTML = html.stripScripts();
  84      setTimeout(function() {html.evalScripts()}, 10);
  85    },
  86    
  87    replace: function(element, html) {
  88      element = $(element);
  89      if (element.outerHTML) {
  90        element.outerHTML = html.stripScripts();
  91      } else {
  92        var range = element.ownerDocument.createRange();
  93        range.selectNodeContents(element);
  94        element.parentNode.replaceChild(
  95          range.createContextualFragment(html.stripScripts()), element);
  96      }
  97      setTimeout(function() {html.evalScripts()}, 10);
  98    },
  99    
 100    getHeight: function(element) {
 101      element = $(element);
 102      return element.offsetHeight; 
 103    },
 104    
 105    classNames: function(element) {
 106      return new Element.ClassNames(element);
 107    },
 108  
 109    hasClassName: function(element, className) {
 110      if (!(element = $(element))) return;
 111      return Element.classNames(element).include(className);
 112    },
 113  
 114    addClassName: function(element, className) {
 115      if (!(element = $(element))) return;
 116      return Element.classNames(element).add(className);
 117    },
 118  
 119    removeClassName: function(element, className) {
 120      if (!(element = $(element))) return;
 121      return Element.classNames(element).remove(className);
 122    },
 123    
 124    // removes whitespace-only text node children
 125    cleanWhitespace: function(element) {
 126      element = $(element);
 127      for (var i = 0; i < element.childNodes.length; i++) {
 128        var node = element.childNodes[i];
 129        if (node.nodeType == 3 && !/\S/.test(node.nodeValue)) 
 130          Element.remove(node);
 131      }
 132    },
 133    
 134    empty: function(element) {
 135      return $(element).innerHTML.match(/^\s*$/);
 136    },
 137    
 138    childOf: function(element, ancestor) {
 139      element = $(element), ancestor = $(ancestor);
 140      while (element = element.parentNode)
 141        if (element == ancestor) return true;
 142      return false;
 143    },
 144    
 145    scrollTo: function(element) {
 146      element = $(element);
 147      var x = element.x ? element.x : element.offsetLeft,
 148          y = element.y ? element.y : element.offsetTop;
 149      window.scrollTo(x, y);
 150    },
 151    
 152    getStyle: function(element, style) {
 153      element = $(element);
 154      var value = element.style[style.camelize()];
 155      if (!value) {
 156        if (document.defaultView && document.defaultView.getComputedStyle) {
 157          var css = document.defaultView.getComputedStyle(element, null);
 158          value = css ? css.getPropertyValue(style) : null;
 159        } else if (element.currentStyle) {
 160          value = element.currentStyle[style.camelize()];
 161        }
 162      }
 163  
 164      if (window.opera && ['left', 'top', 'right', 'bottom'].include(style))
 165        if (Element.getStyle(element, 'position') == 'static') value = 'auto';
 166  
 167      return value == 'auto' ? null : value;
 168    },
 169    
 170    setStyle: function(element, style) {
 171      element = $(element);
 172      for (var name in style) 
 173        element.style[name.camelize()] = style[name];
 174    },
 175    
 176    getDimensions: function(element) {
 177      element = $(element);
 178      if (Element.getStyle(element, 'display') != 'none')
 179        return {width: element.offsetWidth, height: element.offsetHeight};
 180      
 181      // All *Width and *Height properties give 0 on elements with display none,
 182      // so enable the element temporarily
 183      var els = element.style;
 184      var originalVisibility = els.visibility;
 185      var originalPosition = els.position;
 186      els.visibility = 'hidden';
 187      els.position = 'absolute';
 188      els.display = '';
 189      var originalWidth = element.clientWidth;
 190      var originalHeight = element.clientHeight;
 191      els.display = 'none';
 192      els.position = originalPosition;
 193      els.visibility = originalVisibility;
 194      return {width: originalWidth, height: originalHeight};    
 195    },
 196    
 197    makePositioned: function(element) {
 198      element = $(element);
 199      var pos = Element.getStyle(element, 'position');
 200      if (pos == 'static' || !pos) {
 201        element._madePositioned = true;
 202        element.style.position = 'relative';
 203        // Opera returns the offset relative to the positioning context, when an
 204        // element is position relative but top and left have not been defined
 205        if (window.opera) {
 206          element.style.top = 0;
 207          element.style.left = 0;
 208        }  
 209      }
 210    },
 211  
 212    undoPositioned: function(element) {
 213      element = $(element);
 214      if (element._madePositioned) {
 215        element._madePositioned = undefined;
 216        element.style.position =
 217          element.style.top =
 218          element.style.left =
 219          element.style.bottom =
 220          element.style.right = '';   
 221      }
 222    },
 223  
 224    makeClipping: function(element) {
 225      element = $(element);
 226      if (element._overflow) return;
 227      element._overflow = element.style.overflow;
 228      if ((Element.getStyle(element, 'overflow') || 'visible') != 'hidden')
 229        element.style.overflow = 'hidden';
 230    },
 231  
 232    undoClipping: function(element) {
 233      element = $(element);
 234      if (element._overflow) return;
 235      element.style.overflow = element._overflow;
 236      element._overflow = undefined;
 237    }
 238  }
 239  
 240  Object.extend(Element, Element.Methods);
 241  
 242  var _nativeExtensions = false;
 243  
 244  if(!HTMLElement && /Konqueror|Safari|KHTML/.test(navigator.userAgent)) {
 245    var HTMLElement = {}
 246    HTMLElement.prototype = document.createElement('div').__proto__;
 247  }
 248  
 249  Element.addMethods = function(methods) {
 250    Object.extend(Element.Methods, methods || {});
 251    
 252    if(typeof HTMLElement != 'undefined') {
 253      var methods = Element.Methods, cache = Element.extend.cache;
 254      for (property in methods) {
 255        var value = methods[property];
 256        if (typeof value == 'function')
 257          HTMLElement.prototype[property] = cache.findOrStore(value);
 258      }
 259      _nativeExtensions = true;
 260    }
 261  }
 262  
 263  Element.addMethods();
 264  
 265  var Toggle = new Object();
 266  Toggle.display = Element.toggle;
 267  
 268  /*--------------------------------------------------------------------------*/
 269  
 270  Abstract.Insertion = function(adjacency) {
 271    this.adjacency = adjacency;
 272  }
 273  
 274  Abstract.Insertion.prototype = {
 275    initialize: function(element, content) {
 276      this.element = $(element);
 277      this.content = content.stripScripts();
 278      
 279      if (this.adjacency && this.element.insertAdjacentHTML) {
 280        try {
 281          this.element.insertAdjacentHTML(this.adjacency, this.content);
 282        } catch (e) {
 283          var tagName = this.element.tagName.toLowerCase();
 284          if (tagName == 'tbody' || tagName == 'tr') {
 285            this.insertContent(this.contentFromAnonymousTable());
 286          } else {
 287            throw e;
 288          }
 289        }
 290      } else {
 291        this.range = this.element.ownerDocument.createRange();
 292        if (this.initializeRange) this.initializeRange();
 293        this.insertContent([this.range.createContextualFragment(this.content)]);
 294      }
 295  
 296      setTimeout(function() {content.evalScripts()}, 10);   
 297    },
 298    
 299    contentFromAnonymousTable: function() {
 300      var div = document.createElement('div');
 301      div.innerHTML = '<table><tbody>' + this.content + '</tbody></table>';
 302      return $A(div.childNodes[0].childNodes[0].childNodes);
 303    }
 304  }
 305  
 306  var Insertion = new Object();
 307  
 308  Insertion.Before = Class.create();
 309  Insertion.Before.prototype = Object.extend(new Abstract.Insertion('beforeBegin'), {
 310    initializeRange: function() {
 311      this.range.setStartBefore(this.element);
 312    },
 313    
 314    insertContent: function(fragments) {
 315      fragments.each((function(fragment) {
 316        this.element.parentNode.insertBefore(fragment, this.element);
 317      }).bind(this));
 318    }
 319  });
 320  
 321  Insertion.Top = Class.create();
 322  Insertion.Top.prototype = Object.extend(new Abstract.Insertion('afterBegin'), {
 323    initializeRange: function() {
 324      this.range.selectNodeContents(this.element);
 325      this.range.collapse(true);
 326    },
 327    
 328    insertContent: function(fragments) {
 329      fragments.reverse(false).each((function(fragment) {
 330        this.element.insertBefore(fragment, this.element.firstChild);
 331      }).bind(this));
 332    }
 333  });
 334  
 335  Insertion.Bottom = Class.create();
 336  Insertion.Bottom.prototype = Object.extend(new Abstract.Insertion('beforeEnd'), {
 337    initializeRange: function() {
 338      this.range.selectNodeContents(this.element);
 339      this.range.collapse(this.element);
 340    },
 341    
 342    insertContent: function(fragments) {
 343      fragments.each((function(fragment) {
 344        this.element.appendChild(fragment);
 345      }).bind(this));
 346    }
 347  });
 348  
 349  Insertion.After = Class.create();
 350  Insertion.After.prototype = Object.extend(new Abstract.Insertion('afterEnd'), {
 351    initializeRange: function() {
 352      this.range.setStartAfter(this.element);
 353    },
 354    
 355    insertContent: function(fragments) {
 356      fragments.each((function(fragment) {
 357        this.element.parentNode.insertBefore(fragment, 
 358          this.element.nextSibling);
 359      }).bind(this));
 360    }
 361  });
 362  
 363  /*--------------------------------------------------------------------------*/
 364  
 365  Element.ClassNames = Class.create();
 366  Element.ClassNames.prototype = {
 367    initialize: function(element) {
 368      this.element = $(element);
 369    },
 370  
 371    _each: function(iterator) {
 372      this.element.className.split(/\s+/).select(function(name) {
 373        return name.length > 0;
 374      })._each(iterator);
 375    },
 376    
 377    set: function(className) {
 378      this.element.className = className;
 379    },
 380    
 381    add: function(classNameToAdd) {
 382      if (this.include(classNameToAdd)) return;
 383      this.set(this.toArray().concat(classNameToAdd).join(' '));
 384    },
 385    
 386    remove: function(classNameToRemove) {
 387      if (!this.include(classNameToRemove)) return;
 388      this.set(this.select(function(className) {
 389        return className != classNameToRemove;
 390      }).join(' '));
 391    },
 392    
 393    toString: function() {
 394      return this.toArray().join(' ');
 395    }
 396  }
 397  
 398  Object.extend(Element.ClassNames.prototype, Enumerable);