sproutit-sproutcore 1.0.20090721145236 → 1.0.20090721145251

data/frameworks/sproutcore/frameworks/deprecated/system/globals.js

@@ -0,0 +1,20 @@
+// ========================================================================
+// SproutCore -- JavaScript Application Framework
+// Copyright ©2006-2008, Sprout Systems, Inc. and contributors.
+// Portions copyright ©2008 Apple, Inc.  All rights reserved.
+// ========================================================================
+
+// Globally defined variables are no longer supported to allow SproutCore to 
+// work with other libraries.
+// Export the type variables into the global space.
+var T_ERROR = SC.T_ERROR ;
+var T_OBJECT = SC.T_OBJECT ;
+var T_NULL = SC.T_NULL ;
+var T_CLASS = SC.T_CLASS ;
+var T_HASH = SC.T_HASH ;
+var T_FUNCTION = SC.T_FUNCTION ;
+var T_UNDEFINED = SC.T_UNDEFINED ;
+var T_NUMBER = SC.T_NUMBER ;
+var T_BOOL = SC.T_BOOL ;
+var T_ARRAY = SC.T_ARRAY ;
+var T_STRING = SC.T_STRING ;

data/frameworks/sproutcore/frameworks/deprecated/system/misc.js

@@ -0,0 +1,58 @@
+// ========================================================================
+// SproutCore -- JavaScript Application Framework
+// Copyright ©2006-2008, Sprout Systems, Inc. and contributors.
+// Portions copyright ©2008 Apple, Inc.  All rights reserved.
+// ========================================================================
+
+// Legacy.  Will retire.
+SC.mixin(Object,
+/** @scope Object */ {
+
+  /** @deprecated
+   Serialize a general JSON object into a URI.  This method of encoding is 
+   no longer supported or recommended.
+  */
+  serialize: function(obj) {
+    var ret = [] ;
+    for(var key in obj) {
+      var value = obj[key] ;
+      if (typeof value == 'number') { value = '' + value ; }
+      if (!(typeof value == 'string')) { value = value.join(','); }
+      ret.push(encodeURIComponent(key) + "=" + encodeURIComponent(value)) ;
+    }
+    return ret.join('&') ;
+  }
+  
+}) ;
+
+/** @deprecated
+  This will add or remove the class name based on the flag, allowing you to
+  treat it like a bool setting.  Simplifies the common case where you need
+  to make a class name match a bool.
+  
+  Since SproutCore no long requires the Prototype library, this extension to
+  Prototype is also no longer supported.  You can use setClassName() on 
+  SC.ClassicView, or the sproutcore-jquery framework instead.
+*/
+Element.setClassName = function(element,className,flag) {
+  if(SC.browser.isIE)
+  {
+    if (flag) { 
+      Element.addClassName(element,className); 
+    } else {
+      Element.removeClassName(element,className) ;
+    }
+  } 
+  else
+  {
+    if (flag) { 
+      element.addClassName(className); 
+    } else {
+      element.removeClassName(className) ;
+    }
+  } 
+} ;
+
+
+SC.Routes = SC.routes;
+SC.Routes.addRoute = SC.routes.add;

data/frameworks/sproutcore/frameworks/deprecated/system/node_descriptor.js

@@ -0,0 +1,72 @@
+// ========================================================================
+// SproutCore -- JavaScript Application Framework
+// Copyright ©2006-2008, Sprout Systems, Inc. and contributors.
+// Portions copyright ©2008 Apple, Inc.  All rights reserved.
+// ========================================================================
+
+require('core') ;
+
+/**
+  This object can generate HTML DOM elements from a hash-based description of 
+  the nodes.  See the NodeDescriptor wiki page for complete docs.
+
+  See https://wiki.sproutit.com/engineering/show/NodeDescriptor 
+
+  @deprecated
+*/
+SC.NodeDescriptor = {
+  create: function(descriptor, opts) {
+    if (!opts) opts = {} ;
+    // collect info from descriptor
+    var tag = opts.tag || descriptor.tag || 'div' ;
+    var className = opts.cssClass || descriptor.cssClass ;
+    var elementId = opts.id || descriptor.id ;
+    var style = opts.style || descriptor.style ;
+    var innerHTML = opts.innerHTML || descriptor.innerHTML ;
+    if (!innerHTML) {
+      var childNodes = opts.childNodes || descriptor.childNodes ;
+    } 
+
+    // create element
+    var ret = $(document.createElement(tag)) ;
+    if (className) ret.className = className ;
+    if (elementId) ret.id = elementId ;
+    if (style) {
+      for (var name in style) element.style[name.camelize()] = style[name];
+    }
+    
+    // apply extra attributes
+    for(var attr in descriptor) {
+      if (this.ignoredProperties.indexOf(attr) == -1) {
+        ret.setAttribute(attr,descriptor[attr]) ;
+      }
+    }
+    
+    // build child nodes, if they exist.
+    if (innerHTML) {
+      ret.innerHTML = innerHTML ;
+    } else if (childNodes) {
+      var that = this ;
+      childNodes.each(function(desc) {
+        ret.appendChild(that.create(desc)) ;
+      }) ;
+	  that=null;
+	  childNodes=null;
+    }
+    
+	try{
+    	return ret ;
+	}finally{
+		//ie7 memory leaks
+		tag=null;
+		className=null;
+		elementId=null;
+		style=null;
+		innerHTML=null;
+		ret=null;
+	}
+  },
+  
+  ignoredProperties: ['tag','cssClass','id','style','childNodes','innerHTML']
+};
+

data/frameworks/sproutcore/frameworks/deprecated/system/object.js

@@ -0,0 +1,122 @@
+// ========================================================================
+// SproutCore -- JavaScript Application Framework
+// Copyright ©2006-2008, Sprout Systems, Inc. and contributors.
+// Portions copyright ©2008 Apple, Inc.  All rights reserved.
+// ========================================================================
+
+SC.mixin(SC.Object, {
+
+  /**  @deprecated
+    This method will listen for the observed value to change one time and 
+    then will remove itself.  You can also set an optional timeout that
+    will cause the function to be triggered (and the observer removed) after
+    a set amount of time even if the value never changes.  The function
+    can expect an extra parameter, 'didTimeout', set to true.
+  
+    The returned value is the function actually set as the observer. You
+    can manually remove this observer by calling the cancel() method on it.
+  */
+  observeOnce: function(key, target, method, timeout) {
+    
+    // fixup the params
+    var targetType = SC.typeOf(target) ;
+    if (targetType === SC.T_FUNCTION) {
+      if ((SC.typeOf(method) === SC.T_NUMBER) && (timeout === undefined)) {
+        timeout = method ;
+      }
+      method = target ;
+      target = this ;
+    }
+    
+    // convert the method to a function if needed...
+    if (SC.typeOf(method) === SC.T_STRING) method = target[method] ;
+    if (!method) throw "You must pass a valid method to observeOnce()";
+
+    var timeoutObject = null ;
+
+    // define a custom observer that will call the target method and remove
+    // itself as an observer.
+    var handler = function(observer, target, property, value, rev, didTimeout) {
+      // invoke method...
+      method.call(this, observer, target, property, value, rev, didTimeout);
+      
+      // remove observer...
+      target.removeObserver(key, this, handler) ;
+      
+      // if there is a timeout, invalidate it.
+      if (timeoutObject) { timeoutObject.invalidate();}
+      
+      // avoid memory leaks
+      handler = target = method = timeoutObject = null;
+    } ;
+
+    // now add observer
+    target.addObserver(key, target, handler) ;
+    if (timeout) {
+      timeoutObject = function() {
+        handler(null, target, key, target.get(key), target.propertyRevision, true) ;
+        handler = target = method = timeoutObject = null;
+      }.invokeLater(this, timeout) ;
+    }
+
+    handler.cancel = function() { 
+      target.removeObserver(key, target, handler); 
+      handler = target = method = timeoutObject = null;
+    } ;
+
+    return handler ;
+  },
+  
+  /** @deprecated
+    Takes an array of hashes and returns newly created instances.
+    
+    This convenience method will take an array of properties and simply
+    instantiates objects from them.
+    
+    @params {Array} array Array of hashes with properties to assigned to each object.
+    @returns {Array} instantiated objects.
+  */
+  createEach: function(array) {
+    return array.map(function(props) { return this.create(props); }, this);
+  },
+
+  /** @deprecated
+    Adding this function to the end of a view declaration will define the 
+    class as an outlet that can be constructed using the outlet() method 
+    (instead of get()).
+    
+    @returns {Outlet} a specially constructed function that will be used to
+     build the outlet later.
+  */
+  outlet: function() {
+    var obj = this ;
+    return function() {
+      var ret = obj.create() ; ret.owner = this ; return ret ;
+    }.property().cacheable().outlet() ;
+  },
+
+  /** @deprecated
+    Returns all the keys defined on this object, excluding any defined in
+    parent classes unless you pass all.
+    
+    @param {Boolean} all OPTIONAL: if YES return all keys, NO return only keys belonging to object itself.  Defaults to NO.
+    @returns {Array} keys
+  */
+  keys: function(all) {
+    var ret = []; 
+    for(var key in this) { 
+      if (all || ret.hasOwnProperty(key)) ret.push(key); 
+    } 
+    return ret ;  
+  },
+
+  tupleForPropertyPath: SC.tupleForPropertyPath,
+  objectForPropertyPath: SC.objectForPropertyPath,
+  createArray: SC.Object.createEach    
+});
+
+/** @deprecated
+  outlet() now works just like get().  Use get() instead.
+*/ 
+SC.Object.prototype.outlet = SC.Object.prototype.get ;
+

data/frameworks/sproutcore/frameworks/deprecated/system/path_module.js

@@ -0,0 +1,432 @@
+// ========================================================================
+// SproutCore -- JavaScript Application Framework
+// Copyright ©2006-2008, Sprout Systems, Inc. and contributors.
+// Portions copyright ©2008 Apple, Inc.  All rights reserved.
+// ========================================================================
+//
+// When creating a web app, you often need to find elements in your page to
+// configure them on load.  These elements are often marked with a class or
+// id.  General purpose methods such as $$() or getElementsByClassName are
+// not very good for this because they search entire trees of nodes.
+//
+// These methods are much faster because they make some assumptions about 
+// how your elements are structured.
+//
+// ==========================================================================
+
+require('core') ;
+
+// Constants
+SC.BENCHMARK_SELECTOR = NO ;
+NO_LIMIT = 10000 ;
+
+/**
+  PathModule is high-performance API for locating DOM nodes in your HTML
+  document.  It's designed to be used by searching elements from a parent
+  node.  
+
+  PathModule is patched into Prototypes Element.Methods, which means that 
+  you can automatically access this API for any DOM element retrieved via
+  the $() operator.  You can also mixin the PathModule api to your own 
+  objects.  Be sure to also have a property called rootElement that points to 
+  the root DOM element you want to search.
+*/
+SC.PathModule = {
+
+// NOTE: The code below simulates having document.rootElement = document.  
+// we can't actually do this assignment because it will leak memory in IE.
+
+    $$func: function(func, levels, max, nest) {
+      var el = (this.rootElement) ? this.rootElement : (this === document) ? document : null ;
+      return SC._PathModule.$$func(el,func,levels,max,nest);
+    },
+
+    $$C: function(className, levels, max, nest) {
+      var el = (this.rootElement) ? this.rootElement : (this === document) ? document : null ;
+      return SC._PathModule.$$C(el,className,levels,max,nest);
+    },
+
+    $$T: function(tagName, levels, max, nest) {
+      var el = (this.rootElement) ? this.rootElement : (this === document) ? document : null ;
+      return SC._PathModule.$$T(el,tagName,levels,max,nest);
+    },
+
+    $$P: function(property, value, levels, max, nest) {
+      var el = (this.rootElement) ? this.rootElement : (this === document) ? document : null ;
+      return SC._PathModule.$$P(el, property, value, levels, max, nest);
+    },
+
+    $$S: function(selector, levels, max, nest) {
+      var el = (this.rootElement) ? this.rootElement : (this === document) ? document : null ;
+      return SC._PathModule.$$S(el, selector, levels, max, nest);
+    },
+
+    // finds the first node for which func returns true.
+    $func: function(func, levels) {
+      var el = (this.rootElement) ? this.rootElement : (this === document) ? document : null ;
+      return SC._PathModule.$func(el, func, levels);
+    },
+
+    // finds the first node with class name.  returns element, not array.
+    $C: function(className, levels) {
+      var el = (this.rootElement) ? this.rootElement : (this === document) ? document : null ;
+      return SC._PathModule.$C(el, className, levels);
+    },
+
+    // finds the first node with tag name.  returns element, not array.
+    $T: function(tagName, levels) {
+      var el = (this.rootElement) ? this.rootElement : (this === document) ? document : null ;
+      return SC._PathModule.$T(el, tagName, levels);
+    },
+
+    // find first node with an attribute matching then named value.
+    $P: function(attr, value, levels) {
+      var el = (this.rootElement) ? this.rootElement : (this === document) ? document : null ;
+      return SC._PathModule.$P(el, attr, value, levels);
+    },
+
+    // find first node matching the specified class selector.
+    $S: function(selector, levels) {
+      var el = (this.rootElement) ? this.rootElement : (this === document) ? document : null ;
+      return SC._PathModule.$S(el, selector, levels);
+    },
+    
+    // find an element and configure it as the named view if it is not already
+    // configured.
+    $$view: function(selector, viewClass, levels, max, nest) {
+      var el = (this.rootElement) ? this.rootElement : (this === document) ? document : null ;
+      return SC._PathModule.$$view(el, selector, viewClass, levels, max, nest) ;
+    },
+
+    // find the first element matching the selector and create a view if it is
+    // not already configured.
+    $view: function(selector, viewClass, levels) {
+      var el = (this.rootElement) ? this.rootElement : (this === document) ? document : null ;
+      return SC._PathModule.$view(el, selector, viewClass, levels) ;
+    }
+    
+};
+
+// This version of PathModule can be added to Element.Methods among others.
+// It is the same API except that it passes the element as the first parameter.
+SC._PathModule = {
+
+  // this is the core method that needs to be implemented for each object.
+  // this method will search the receiver (up to _levels_ deep) for _max_
+  // elements for which the function func() returns true. 
+  //
+  // el:     (req) the root element.  If you pass null, document will be used. 
+  // func:   (req) the function to be used to check each element.
+  // levels: (opt) the max levels deep in nested elements. defaults: NO_LIMIT
+  // max:    (opt) the maximum number of elements to return. defaults: 
+  //         NO_LIMIT
+  // nest:   (opt) if true, then the children of matched elements will also be
+  //         searched.  if your element matches will never be nested, setting
+  //         this to false can be much faster.  defaults: false
+  $$func: function(el, func, levels, max, nest) {
+    // defaults
+    levels = levels || NO_LIMIT ; max = max || NO_LIMIT; nest = nest || false;
+    
+    // function to search this node.
+    var searchNode = function(node, depth, remain, includeThisNode) {
+      var ret = [] ;
+      
+      // does this node match?
+      // we extend any returned elements so you can chain these methods. 
+      // on browsers that support HTMLElement.prototype, this will do nothing.
+      var match = (includeThisNode) ? func(node) : false ;
+      if (match) { ret.push(node); remain--; }
+
+      // can we search children?
+      depth-- ;
+      if ((match && !nest) || (remain<=0) || (depth<=0)) return ret;
+
+      // search children.
+      node = node.firstChild ;
+      while(node && (remain > 0)) {
+        var found = searchNode(node,depth,remain,true) ;
+        remain -= found.length ;
+        ret = ret.concat(found) ;
+        node = node.nextSibling ;
+      }
+      return ret ;
+    } ;
+    
+    return searchNode(el || document, levels+1, max, false) ;
+  },
+  
+  // finds all nodes with class name.
+  $$C: function(el, className, levels, max, nest) {
+    return SC._PathModule.$$func(el, function(node) {
+      return Element.hasClassName(node, className) ; 
+    }, levels, max, nest) ;
+  },
+  
+  // find all nodes with tag name
+  $$T: function(el, tagName, levels, max, nest) {
+    tagName = tagName.toUpperCase() ;
+    return SC._PathModule.$$func(el, function(node) { 
+      return node.tagName == tagName; 
+    }, levels, max, nest) ;
+  },
+
+  // find all nodes with an attribute matching then named value.
+  $$P: function(el, property, value, levels, max, nest) {
+    return SC._PathModule.$$func(el, function(node) { 
+      var pvalue = (node.getAttribute) ? node.getAttribute(property) : node[property] ;
+      return pvalue == value; 
+    }, levels, max, nest) ;
+  },
+
+  // this will parse the selector and then execute the selectors to return
+  // the result.  this understands a very simple form for selectors. the 
+  // parts are split by spaces. and treated like so:
+  // '.classname' = class name
+  // 'tag' = tag
+  // '#id' = an id. (this will bypass the normal selector methods) 
+  // 'attr=value' = find an attr with the value.
+  //
+  // understands the following qualifiers:
+  // .selector:3   => find .selector at most 3 levels deep
+  // .selector:3:4 => find at most 4 .selectors at most 3 levels deep
+  // .selector?    => find at most 1 .selector, any depth.
+  // .selector?3   => find at most 3 .selectors, any depth
+  // .selector:*:4 => find at more 4 .selectors at any depth.
+  // 
+  // You can also directly access child nodes by doing:
+  // .selector[0][1][3] -> get child 3 of child 1 of child 0.
+  // or:
+  // [0][2][3] -> search base.
+  //
+  $$S: function(el,selector, levels, max, nest) {
+    var parts = selector.split(' ') ;
+    var ret = [el] ; var nextMax = null ; var bits ;
+    var blevels; var bmax; var q; var indicies ;
+
+    parts.each(function(part) {
+      // this is included for compatibility with earlier changes I made to
+      // prototype.  the preferred way to do this in the future is with with
+      // the colon format.
+      if (part == '?') { nextMax = 1; return ; }
+
+      // get defaults
+      blevels = levels; bmax = (nextMax) ? nextMax : max ;
+      nextMax = null ;
+
+      // if there are indexes, find those and save them.
+      if (part.slice(part.length-1,part.length) == ']') {
+        bits = part.split('[') ;
+        part = bits.shift();
+        indicies = bits.map(function(b) {return parseInt(b.slice(0,-1),0);});
+      } else indicies = null ;
+
+      // find found modifiers
+      bits = part.split('?') ;
+      part = bits[0] ;
+      if (bits.length > 1) {
+        bmax = (bits[1].length == 0) ? 1 : parseInt(bits[1],0) ;
+      }
+
+      // find level modifiers
+      bits = part.split(':') ;
+      part = bits[0] ;
+      if (bits.length > 1) blevels = (bits[1] == '*') ? '*' : parseInt(bits[1],0) ;
+      if (bits.length > 2) bmax = (bits[2] == '*') ? '*' : parseInt(bits[2],0) ;
+
+      // convert star to NO_LIMIT
+      if (blevels == '*') blevels = NO_LIMIT ;
+      if (bmax == '*') bmax = NO_LIMIT ;
+
+      // prepare the selector info.
+      // q tells us how to process the first part.
+      // part is the first part of the selector
+      // bits are any extra css selectors.
+      if (part && part.length > 0) {
+        q = part.slice(0,1) ; 
+        if (['.','#'].indexOf(q) >= 0) { 
+          part = part.slice(1,part.length) ; 
+        }
+        
+        bits = part.split('.') ;
+        part = bits[0] ;
+        bits = bits.slice(1,bits.length) ;
+
+        // optimization for # types.
+        var fret = null ;
+        if (q == '#') {
+          fret = $(part) ;
+          fret = (fret) ? [fret] : null ;
+          if (fret) ret = fret ;
+        }
+        
+        // otherwise pass this off to $$func to actually search.
+        if (fret == null) {
+          fret = [] ;
+          for(var i=0;i<ret.length;i++) {
+
+            var found = SC._PathModule.$$func(ret[i],function(node) {
+              var match ;
+              switch(q) {
+                case '.':
+                  NODE = node ;
+                  var elementClassName = node.className;
+                  if (elementClassName && (elementClassName.length > 0)) {
+                    match = (elementClassName == part ||
+                      elementClassName.match( new RegExp("(^|\\s)" + part + 
+                        "(\\s|$)"))) ;
+                  } else match = false ;
+                  break ;
+                case '#':
+                  match = node.id == part ;
+                  break ;
+                default:
+                  if (node.tagName) {
+                    match = (node.tagName.toLowerCase() == part.toLowerCase()) ;
+                  } else { match = false; }
+              }
+
+              // if the first item matched, verify that the others match as well.
+              var ilen = bits.length ;
+              for(var i=0; match && i < ilen; i++) {
+                if (!Element.hasClassName(node,bits[i])) match = false ; 
+              }
+              return match ; 
+            }, blevels, bmax, nest) ;
+            fret = fret.concat(found) ;
+          }
+          ret = fret ;
+        }
+      } else if (SC.typeOf(ret) != SC.T_ARRAY) ret = [ret] ;
+
+      // now follow indicies, if there are any
+      if (indicies && indicies.length > 0 && ret) {
+        ret = ret.map(function(el){
+          var iloclen = indicies.length ;
+          for(var iloc=0; el && (iloc < iloclen); iloc++) {
+            el = el.childNodes[indicies[iloc]] ;
+          }
+          return el;
+        }) ;
+      }
+    }) ;
+    return ret ;
+  },
+
+  // finds the first node for which func returns true.
+  $func: function(el,func, levels) {
+    var ret = SC._PathModule.$$func(el,func,levels,1,false) ;
+    return (ret.length>0) ? ret[0] : null ;
+  },
+
+  // finds the first node with class name.  returns element, not array.
+  $C: function(el, className, levels) {
+    var ret = SC._PathModule.$$C(el, className,levels,1,false) ;
+    return (ret.length>0) ? ret[0] : null ;
+  },
+
+  // finds the first node with tag name.  returns element, not array.
+  $T: function(el, tagName, levels) {
+    var ret = SC._PathModule.$$T(el, tagName,levels,1,false) ;
+    return (ret.length>0) ? ret[0] : null ;
+  },
+
+  // find first node with an attribute matching then named value.
+  $P: function(el, attr, value, levels) {
+    var ret = SC._PathModule.$$P(el, attr, value,levels,1,false) ;
+    return (ret.length>0) ? ret[0] : null ;
+  },
+
+  // find first node matching the specified class selector.
+  $S: function(el, selector, levels) {
+    var ret = SC._PathModule.$$S(el, selector,levels,1,false) ;
+    return (ret.length>0) ? ret[0] : null ;
+  },
+  
+  // find an element and configure it as the named view if it is not already
+  // configured.
+  $$view: function(el, selector, viewClass, levels, max, nest) {
+    //if (!viewClass) viewClass = SC.ClassicView;
+    var ret ;
+    if (selector && (typeof(selector) != 'string')) {
+      ret = [selector] ;
+    } else {
+      ret = SC._PathModule.$$S(el,selector,levels,max,nest) ;
+    }
+    if (ret) ret = ret.map(function(x) { return (viewClass) ? viewClass.viewFor(x) : SC.ClassicView.findViewForElement(x); }) ;
+    return ret ;
+  },
+
+  // find the first element matching the selector and create a view if it is
+  // not already configured.
+  $view: function(el, selector, viewClass, levels) {
+    var ret = SC._PathModule.$$view(el, selector, viewClass, levels, 1, false) ;
+    return (ret.length>0) ? ret[0] : null ;
+  }
+  
+} ;
+
+// Install benchmark report for selector if configured.
+if (SC.BENCHMARK_SELECTOR) {
+  ['$$S','$$C','$$T','$S','$C','$T'].each(function(mname) {
+    SC.Benchmark.install(SC._PathModule,mname) ;
+  })  ;
+  SC.Benchmark.install(window,'$$$') ;
+}
+
+// longer form aliases of the functions.
+SC.mixin(SC._PathModule, {
+  $$class: SC._PathModule.$$C,
+  $$tag: SC._PathModule.$$T,
+  $$sel: SC._PathModule.$$S,
+  $$prop: SC._PathModule.$$P,
+  
+  $class: SC._PathModule.$C,
+  $tag: SC._PathModule.$T,
+  $sel: SC._PathModule.$S,
+  $prop: SC._PathModule.$P
+}) ;
+
+// longer form aliases of the functions.
+SC.mixin(SC.PathModule, {
+  $$class: SC.PathModule.$$C,
+  $$tag: SC.PathModule.$$T,
+  $$sel: SC.PathModule.$$S,
+  $$prop: SC.PathModule.$$P,
+  
+  $class: SC.PathModule.$C,
+  $tag: SC.PathModule.$T,
+  $sel: SC.PathModule.$S,
+  $prop: SC.PathModule.$P
+}) ;
+
+// Add _PathModule to the appropriate elements.  Add to Element.Methods which
+// will cause it to be copied onto elements automatically in IE when you 
+// call IE.
+SC.mixin(Element.Methods,SC._PathModule) ;
+SC.mixin(Element,SC._PathModule) ;
+
+// applies to Element.
+if (typeof HTMLElement != 'undefined') {
+  SC.mixin(HTMLElement.prototype,SC.PathModule) ;
+}
+
+// applies to document
+SC.mixin(document,SC.PathModule) ;
+
+// applies to window.
+SC.mixin(SC.mixin(window,SC.PathModule), {
+  $$func: function(func, levels, max, nest) {
+    return document.$$func(func,levels,max,nest) ;
+  }
+});
+
+// applies to arrays. Note the override of $$func to act on the group.
+SC.mixin(SC.mixin(Array.prototype,SC.PathModule), {
+  $$func: function(func, levels, max, nest) {
+    var ret = [] ;
+    for(var loc=0;loc<this.length;loc++) {
+      ret = ret.concat(this[loc].$$func(func,levels,max,nest)) ;
+    }
+    return ret ;
+  }
+}) ;