[Sommaire] [Imprimer]

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