sproutcore 1.4.5 → 1.5.0.pre.3

data/lib/frameworks/sproutcore/frameworks/amber/core.js

@@ -0,0 +1,201 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2010 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+/**
+  Indicates that the collection view expects to accept a drop ON the specified
+  item.
+  
+  @property {Number}
+*/
+SC.DROP_ON = 0x01 ;
+
+/**
+  Indicates that the collection view expects to accept a drop BEFORE the 
+  specified item.
+  
+  @property {Number}
+*/
+SC.DROP_BEFORE = 0x02 ;
+
+/**
+  Indicates that the collection view expects to accept a drop AFTER the
+  specified item.  This is treated just like SC.DROP_BEFORE is most views
+  except for tree lists.
+  
+  @property {Number}
+*/
+SC.DROP_AFTER = 0x04 ;
+
+/**
+  Indicates that the collection view want's to know which operations would 
+  be allowed for either drop operation.
+  
+  @property {Number}
+*/
+SC.DROP_ANY = 0x07 ;
+
+/**
+  Indicates that the content should be aligned to the left.
+*/
+SC.ALIGN_LEFT = 'left';
+
+/**
+  Indicates that the content should be aligned to the right.
+*/
+SC.ALIGN_RIGHT = 'right';
+
+/**
+  Indicates that the content should be aligned to the center.
+*/
+SC.ALIGN_CENTER = 'center';
+
+/**
+  Indicates that the content should be aligned to the top.
+*/
+SC.ALIGN_TOP = 'top';
+
+/**
+  Indicates that the content should be aligned to the middle.
+*/
+SC.ALIGN_MIDDLE = 'middle';
+
+/**
+  Indicates that the content should be aligned to the bottom.
+*/
+SC.ALIGN_BOTTOM = 'bottom';
+
+/**
+  Indicates that the content should be aligned to the top and left.
+*/
+SC.ALIGN_TOP_LEFT = 'top-left';
+
+/**
+  Indicates that the content should be aligned to the top and right.
+*/
+SC.ALIGN_TOP_RIGHT = 'top-right';
+
+/**
+  Indicates that the content should be aligned to the bottom and left.
+*/
+SC.ALIGN_BOTTOM_LEFT = 'bottom-left';
+
+/**
+  Indicates that the content should be aligned to the bottom and right.
+*/
+SC.ALIGN_BOTTOM_RIGHT = 'bottom-right';
+
+/**
+  This variable is here to make the tab focus behavior work like safari's.
+*/
+SC.SAFARI_FOCUS_BEHAVIOR = YES;
+
+SC.mixin(/** @lends SC */ {
+  
+  /**
+    Reads or writes data from a global cache.  You can use this facility to
+    store information about an object without actually adding properties to
+    the object itself.  This is needed especially when working with DOM,
+    which can leak easily in IE.
+    
+    To read data, simply pass in the reference element (used as a key) and
+    the name of the value to read.  To write, also include the data.
+    
+    You can also just pass an object to retrieve the entire cache.
+    
+    @param elem {Object} An object or Element to use as scope
+    @param name {String} Optional name of the value to read/write
+    @param data {Object} Optional data.  If passed, write.
+    @returns {Object} the value of the named data
+  */
+  data: function(elem, name, data) {
+    elem = (elem === window) ? "@window" : elem ;
+    var hash = SC.hashFor(elem) ; // get the hash key
+    
+    // Generate the data cache if needed
+    var cache = SC._data_cache ;
+    if (!cache) SC._data_cache = cache = {} ;
+    
+    // Now get cache for element
+    var elemCache = cache[hash] ;
+    if (name && !elemCache) cache[hash] = elemCache = {} ;
+    
+    // Write data if provided 
+    if (elemCache && (data !== undefined)) elemCache[name] = data ;
+    
+    return (name) ? elemCache[name] : elemCache ;
+  },
+  
+  /**
+    Removes data from the global cache.  This is used throughout the
+    framework to hold data without creating memory leaks.
+    
+    You can remove either a single item on the cache or all of the cached 
+    data for an object.
+    
+    @param elem {Object} An object or Element to use as scope
+    @param name {String} optional name to remove. 
+    @returns {Object} the value or cache that was removed
+  */
+  removeData: function(elem, name) {
+    elem = (elem === window) ? "@window" : elem ;
+    var hash = SC.hashFor(elem) ;
+    
+    // return undefined if no cache is defined
+    var cache = SC._data_cache ;
+    if (!cache) return undefined ;
+    
+    // return undefined if the elem cache is undefined
+    var elemCache = cache[hash] ;
+    if (!elemCache) return undefined;
+    
+    // get the return value
+    var ret = (name) ? elemCache[name] : elemCache ;
+    
+    // and delete as appropriate
+    if (name) {
+      delete elemCache[name] ;
+    } else {
+      delete cache[hash] ;
+    }
+    
+    return ret ;
+  }
+}) ;
+
+SC.mixin(Function.prototype, /** @scope Function.prototype */ {
+  /**
+    Creates a timer that will execute the function after a specified 
+    period of time.
+    
+    If you pass an optional set of arguments, the arguments will be passed
+    to the function as well.  Otherwise the function should have the 
+    signature:
+    
+    {{{
+      function functionName(timer)
+    }}}
+
+    @param target {Object} optional target object to use as this
+    @param interval {Number} the time to wait, in msec
+    @returns {SC.Timer} scheduled timer
+  */
+  invokeLater: function(target, interval) {
+    if (interval === undefined) interval = 1 ;
+    var f = this;
+    if (arguments.length > 2) {
+      var args = SC.$A(arguments).slice(2,arguments.length);
+      args.unshift(target);
+      // f = f.bind.apply(f, args) ;
+      var func = f ;
+      // Use "this" in inner func because it get its scope by 
+      // outer func f (=target). Could replace "this" with target for clarity.
+      f = function() { return func.apply(this, args.slice(1)); } ;
+    }
+    return SC.Timer.schedule({ target: target, action: f, interval: interval });
+  }    
+
+});

data/lib/frameworks/sproutcore/frameworks/{foundation → amber}/ext/object.js

@@ -7,33 +7,33 @@
 
 // Extensions to the core SC.Object class
 SC.mixin(SC.Object.prototype, /** @scope SC.Object.prototype */ {
-  
+
   /**
     Invokes the named method after the specified period of time.
-    
+
     This is a convenience method that will create a single run timer to
     invoke a method after a period of time.  The method should have the
     signature:
-    
+
     {{{
       methodName: function(timer)
     }}}
-    
+
     If you would prefer to pass your own parameters instead, you can instead
     call invokeLater() directly on the function object itself.
-    
+
     @param methodName {String} method name to perform.
     @param interval {Number} period from current time to schedule.
     @returns {SC.Timer} scheduled timer.
   */
   invokeLater: function(methodName, interval) {
-    if (interval === undefined) interval = 1 ;
+    if (interval === undefined) { interval = 1 ; }
     var f = methodName, args, func;
-    
+
     // if extra arguments were passed - build a function binding.
     if (arguments.length > 2) {
       args = SC.$A(arguments).slice(2);
-      if (SC.typeOf(f) === SC.T_STRING) f = this[methodName] ;
+      if (SC.typeOf(f) === SC.T_STRING) { f = this[methodName] ; }
       func = f ;
       f = function() { return func.apply(this, args); } ;
     }
@@ -41,24 +41,24 @@ SC.mixin(SC.Object.prototype, /** @scope SC.Object.prototype */ {
     // schedule the timer
     return SC.Timer.schedule({ target: this, action: f, interval: interval });
   },
-  
+
   /**
-    Lookup the named property path and then invoke the passed function, 
+    Lookup the named property path and then invoke the passed function,
     passing the resulting value to the function.
-    
-    This method is a useful way to handle deferred loading of properties.  
+
+    This method is a useful way to handle deferred loading of properties.
     If you want to defer loading a property, you can override this method.
     When the method is called, passing a deferred property, you can load the
     property before invoking the callback method.
-    
-    You can even swap out the receiver object.  
-    
+
+    You can even swap out the receiver object.
+
     The callback method should have the signature:
-    
+
     function callback(objectAtPath, sourceObject) { ... }
-    
+
     You may pass either a function itself or a target/method pair.
-    
+
     @param {String} pathName
     @param {Object} target target or method
     @param {Function|String} method
@@ -69,15 +69,15 @@ SC.mixin(SC.Object.prototype, /** @scope SC.Object.prototype */ {
     if (method === undefined) {
       method = target; target = this;
     }
-    if (!target) target = this ;
-    if (SC.typeOf(method) === SC.T_STRING) method = target[method];
-    
+    if (!target) { target = this ; }
+    if (SC.typeOf(method) === SC.T_STRING) { method = target[method]; }
+
     // get value
     var v = this.getPath(pathName);
-    
+
     // invoke method
     method.call(target, v, this);
     return this ;
   }
-  
+
 });

data/lib/frameworks/sproutcore/frameworks/{foundation → amber}/ext/run_loop.js

@@ -5,51 +5,51 @@
 // License:   Licensed under MIT license (see license.js)
 // ==========================================================================
 
-// Create anonymous subclass of SC.RunLoop to add support for processing 
+// Create anonymous subclass of SC.RunLoop to add support for processing
 // view queues and Timers.
 SC.RunLoop = SC.RunLoop.extend(
 /** @scope SC.RunLoop.prototype */ {
 
   /**
     The time the current run loop began executing.
-    
-    All timers scheduled during this run loop will begin executing as if 
+
+    All timers scheduled during this run loop will begin executing as if
     they were scheduled at this time.
-  
+
     @property {Number}
   */
   startTime: function() {
-    if (!this._start) this._start = Date.now();
-    return this._start ;  
+    if (!this._start) { this._start = Date.now(); }
+    return this._start ;
   }.property(),
-  
-  /* 
-  
+
+  /*
+
     Override to fire and reschedule timers once per run loop.
-    
-    Note that timers should fire only once per run loop to avoid the 
-    situation where a timer might cause an infinite loop by constantly 
+
+    Note that timers should fire only once per run loop to avoid the
+    situation where a timer might cause an infinite loop by constantly
     rescheduling itself everytime it is fired.
   */
   endRunLoop: function() {
     this.fireExpiredTimers(); // fire them timers!
     var ret = sc_super(); // do everything else
     this.scheduleNextTimeout(); // schedule a timout if timers remain
-    return ret; 
+    return ret;
   },
-  
+
   // ..........................................................
   // TIMER SUPPORT
-  // 
-  
+  //
+
   /**
-    Schedules a timer to execute at the specified runTime.  You will not 
+    Schedules a timer to execute at the specified runTime.  You will not
     usually call this method directly.  Instead you should work with SC.Timer,
     which will manage both creating the timer and scheduling it.
-    
-    Calling this method on a timer that is already scheduled will remove it 
+
+    Calling this method on a timer that is already scheduled will remove it
     from the existing schedule and reschedule it.
-    
+
     @param {SC.Timer} timer the timer to schedule
     @param {Time} runTime the time offset when you want this to run
     @returns {SC.RunLoop} receiver
@@ -57,17 +57,17 @@ SC.RunLoop = SC.RunLoop.extend(
   scheduleTimer: function(timer, runTime) {
     // if the timer is already in the schedule, remove it.
     this._timerQueue = timer.removeFromTimerQueue(this._timerQueue);
-    
-    // now, add the timer ot the timeout queue.  This will walk down the 
+
+    // now, add the timer ot the timeout queue.  This will walk down the
     // chain of timers to find the right place to insert it.
     this._timerQueue = timer.scheduleInTimerQueue(this._timerQueue, runTime);
     return this ;
   },
-  
+
   /**
-    Removes the named timer from the timeout queue.  If the timer is not 
+    Removes the named timer from the timeout queue.  If the timer is not
     currently scheduled, this method will have no effect.
-    
+
     @param {SC.Timer} timer the timer to schedule
     @returns {SC.RunLoop} receiver
   */
@@ -78,62 +78,62 @@ SC.RunLoop = SC.RunLoop.extend(
 
   /** @private - shared array used by fireExpiredTimers to avoid memory */
   TIMER_ARRAY: [],
-  
+
   /**
     Invokes any timers that have expired since this method was last called.
-    Usually you will not call this method directly, but it will be invoked 
+    Usually you will not call this method directly, but it will be invoked
     automatically at the end of the run loop.
-    
+
     @returns {Boolean} YES if timers were fired, NO otherwise
   */
   fireExpiredTimers: function() {
-    if (!this._timerQueue || this._firing) return NO; // nothing to do
+    if (!this._timerQueue || this._firing) { return NO; } // nothing to do
 
     // max time we are allowed to run timers
     var now = this.get('startTime'),
         timers = this.TIMER_ARRAY,
         idx, len, didFire;
-    
+
     // avoid recursive calls
     this._firing = YES;
-    
-    // collect timers to fire.  we do this one time up front to avoid infinite 
-    // loops where firing a timer causes it to schedule itself again, causing 
+
+    // collect timers to fire.  we do this one time up front to avoid infinite
+    // loops where firing a timer causes it to schedule itself again, causing
     // it to fire again, etc.
     this._timerQueue = this._timerQueue.collectExpiredTimers(timers, now);
 
     // now step through timers and fire them.
     len = timers.length;
-    for(idx=0;idx<len;idx++) timers[idx].fire();
-    
+    for(idx=0;idx<len;idx++) { timers[idx].fire(); }
+
     // cleanup
     didFire = timers.length > 0 ;
     timers.length = 0 ; // reset for later use...
     this._firing = NO ;
-    return didFire; 
+    return didFire;
   },
-  
+
   /** @private
     Invoked at the end of a runloop, if there are pending timers, a timeout
-    will be scheduled to fire when the next timer expires.  You will not 
+    will be scheduled to fire when the next timer expires.  You will not
     usually call this method yourself.  It is invoked automatically at the
     end of a run loop.
-    
+
     @returns {Boolean} YES if a timeout was scheduled
   */
   scheduleNextTimeout: function() {
     var timer = this._timerQueue ;
-    
+
     var ret = NO ;
     // if no timer, and there is an existing timeout, cancel it
     if (!timer) {
-      if (this._timeout) clearTimeout(this._timeout);
-      
+      if (this._timeout) { clearTimeout(this._timeout); }
+
     // otherwise, determine if the timeout needs to be rescheduled.
     } else {
       var nextTimeoutAt = timer._timerQueueRunTime ;
       if (this._timeoutAt !== nextTimeoutAt) { // need to reschedule
-        if (this._timeout) clearTimeout(this._timeout); // clear existing...
+        if (this._timeout) { clearTimeout(this._timeout); } // clear existing...
         // reschedule
         var delay = Math.max(0, nextTimeoutAt - Date.now());
         this._timeout = setTimeout(this._timeoutDidFire, delay);
@@ -141,14 +141,14 @@ SC.RunLoop = SC.RunLoop.extend(
       }
       ret = YES ;
     }
-    
+
     return ret ;
   },
 
   /** @private
-    Invoked when a timeout actually fires.  Simply cleanup, then begin and end 
+    Invoked when a timeout actually fires.  Simply cleanup, then begin and end
     a runloop. This will fire any expired timers and reschedule.  Note that
-    this function will be called with 'this' set to the global context, 
+    this function will be called with 'this' set to the global context,
     hence the need to lookup the current run loop.
   */
   _timeoutDidFire: function() {
@@ -156,7 +156,7 @@ SC.RunLoop = SC.RunLoop.extend(
     rl._timeout = rl._timeoutAt = null ; // cleanup
     SC.run();  // begin/end runloop to trigger timers.
   }
-  
+
 });
 
 SC.RunLoop.currentRunLoop = SC.RunLoop.create();