sproutit-sproutcore 1.0.20090721145236 → 1.0.20090721145251

data/frameworks/sproutcore/frameworks/foundation/ext/run_loop.js

@@ -0,0 +1,158 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+// 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 
+    they were scheduled at this time.
+  
+    @property {Number}
+  */
+  startTime: function() {
+    if (!this._start) this._start = Date.now();
+    return this._start ;  
+  }.property(),
+  
+  /** @private - 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 
+    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; 
+  },
+  
+  // ..........................................................
+  // TIMER SUPPORT
+  // 
+  
+  /**
+    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 
+    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
+  */
+  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 
+    // 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 
+    currently scheduled, this method will have no effect.
+    
+    @param {SC.Timer} timer the timer to schedule
+    @returns {SC.RunLoop} receiver
+  */
+  cancelTimer: function(timer) {
+    this._timerQueue = timer.removeFromTimerQueue(this._timerQueue) ;
+    return this ;
+  },
+
+  /** @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 
+    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
+
+    // max time we are allowed to run timers
+    var now = this.get('startTime') ;
+    
+    // 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 
+    // it to fire again, etc.
+    var timers = this.TIMER_ARRAY ;
+    this._timerQueue = this._timerQueue.collectExpiredTimers(timers, now);
+
+    // now step through timers and fire them.
+    var idx, len = timers.length;
+    for(idx=0;idx<len;idx++) timers[idx].fire();
+    
+    // cleanup
+    var didFire = timers.length > 0 ;
+    timers.length = 0 ; // reset for later use...
+    this._firing = NO ;
+    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 
+    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);
+      
+    // 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...
+        // reschedule
+        var delay = Math.max(0, nextTimeoutAt - Date.now());
+        this._timeout = setTimeout(this._timeoutDidFire, delay);
+        this._timeoutAt = nextTimeoutAt ;
+      }
+      ret = YES ;
+    }
+    
+    return ret ;
+  },
+
+  /** @private
+    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, 
+    hence the need to lookup the current run loop.
+  */
+  _timeoutDidFire: function() {
+    var rl = SC.RunLoop.currentRunLoop;
+    rl._timeout = rl._timeoutAt = null ; // cleanup
+    SC.RunLoop.begin().end();  // begin/end runloop to trigger timers.
+  }
+  
+});
+
+SC.RunLoop.currentRunLoop = SC.RunLoop.create();

data/frameworks/sproutcore/frameworks/foundation/fixtures/file_exists.json

@@ -0,0 +1 @@
+{"message": "Yay!"}

data/frameworks/sproutcore/frameworks/foundation/license.js

@@ -0,0 +1,19 @@
+/*! @license
+
+Portions of this software are copyright Yahoo, Inc, used under the following license:
+
+Software License Agreement (BSD License)
+Copyright (c) 2009, Yahoo! Inc.
+All rights reserved.
+Redistribution and use of this software in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the
+following disclaimer.
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+Neither the name of Yahoo! Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission of Yahoo! Inc.
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Sources of Intellectual Property Included in the YUI Library
+Where not otherwise indicated, all YUI content is authored by Yahoo! engineers and consists of Yahoo!-owned intellectual property. YUI is issued by Yahoo! under the BSD license above. In some specific instances, YUI will incorporate work done by developers outside of Yahoo! with their express permission.
+
+*/

data/frameworks/sproutcore/frameworks/foundation/mixins/button.js

@@ -0,0 +1,299 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+/** @static
+
+  This mixin implements many of the basic state-handling attributes for 
+  button-like views, including an auto-updated title, and mapping the current
+  value to an isSelected state.
+  
+  Usually you will not work with this mixin directly.  Instead, you should use
+  a class that incorporates the mixin such as SC.ButtonView, SC.CheckboxView
+  or SC.RadioView.
+  
+  This mixin assumes you have already applied the SC.Control and 
+  SC.DelegateSupport mixins as well.
+  
+  @since SproutCore 1.0  
+*/
+SC.Button = {
+  
+  // ..........................................................
+  // VALUE PROPERTIES
+  // 
+  
+  /**
+    Used to automatically update the state of the button view for toggle style
+    buttons.
+
+    for toggle style buttons, you can set the value and it will be used to
+    update the isSelected state of the button view.  The value will also
+    change as the user selects or deselects.  You can control which values
+    the button will treat as isSelected by setting the toggleOnValue and 
+    toggleOffValue.  Alternatively, if you leave these properties set to
+    YES or NO, the button will do its best to convert a value to an 
+    appropriate state:
+  
+    - null, false, 0  -> isSelected = false
+    - any other single value -> isSelected = true
+    - array -> if all values are the same state: that state.  otherwise MIXED.
+    
+    @property {Object}
+  */  
+  value: null,
+  
+  /**
+    Value of a selected toggle button.
+  
+    for a toggle button, set this to any object value you want.  The button
+    will be selected if the value property equals the targetValue.  If the
+    value is an array of multiple items that contains the targetValue, then
+    the button will be set to a mixed state.
+
+    default is YES
+    
+    @property {Object}
+  */
+  toggleOnValue: YES,
+
+  /**
+    Value of an unselected toggle button.
+  
+    For a toggle button, set this to any object value you want.  When the
+    user toggle's the button off, the value of the button will be set to this
+    value.
+  
+    default is NO 
+  
+    @property {Object}
+  */
+  toggleOffValue: NO,
+  
+  // ..........................................................
+  // TITLE 
+  // 
+  
+  /**
+    If YES, then the title will be localized.
+  */
+  localize: NO,
+  localizeBindingDefault: SC.Binding.bool(),
+
+  /**
+    The button title.  If localize is YES, then this should be the localization key to display.  Otherwise, this will be the actual string displayed in the title.  This property is observable and bindable.
+    
+    @property {String}
+  */  
+  title: '',
+
+  /**
+    If you set this property, the title property will be updated automatically
+    from the content using the key you specify.
+  */
+  contentTitleKey: null,
+  
+  /**
+    The button icon.  Set this to either a URL or a CSS class name (for 
+    spriting).  To display an icon, you must set hasIcon to YES when the 
+    button is created.  Note that if you pass a URL, it must contain at 
+    least one slash to be detected as such.
+    
+    @property {String}
+  */
+  icon: null,
+
+  /**
+    If you set this property, the icon will be updated automatically from the
+    content using the key you specify.
+  */
+  contentIconKey: null,
+  
+  /**
+    The computed display title.  This is generated by localizing the title property if necessary.
+    
+    @property {String}
+  */
+  displayTitle: function() {
+    var ret = this.get('title');
+    return (ret && this.get('localize')) ? ret.loc() : (ret || '');
+  }.property('title','localize').cacheable(),
+  
+  /**
+    Classes that include this mixin can invoke this method from their 
+    render method to render the proper title HTML.  This will include an 
+    icon if necessary along with any other standard markup.
+  */
+  renderTitle: function(context, firstTime) {
+    var icon = this.get('icon') ;
+    var image = '' ;
+    var title = this.get('displayTitle') ;
+    var needsTitle = (!SC.none(title) && title.length>0);
+    var elem;
+    // get the icon.  If there is an icon, then get the image and update it.
+    // if there is no image element yet, create it and insert it just before
+    // title.
+    if (icon) {
+      var blank = static_url('blank');
+
+      image = '<img src="%@1" alt="" class="%@2" />' ;
+      if (icon.indexOf('/') >= 0) {
+        image = image.fmt(icon, 'icon');
+      } else {
+        image = image.fmt(blank, icon);
+      }
+      needsTitle = YES ;
+    }
+    
+    elem = this.$('label');
+    if (!firstTime && elem[0]){
+      if(needsTitle) { elem[0].innerHTML = image + title; }
+      else { this.$()[0].innerHTML = ''; } 
+    } else {
+      if(needsTitle) { 
+        context.begin('label').addClass('sc-button-label').push(image, title).end();   
+      }
+    }
+    return context ;
+  },
+
+  /**
+    Updates the value, title, and icon keys based on the content object, if 
+    set.
+  */
+  contentPropertyDidChange: function(target, key) {
+    var del = this.get('displayDelegate');
+    var content = this.get('content'), value ;
+
+    var valueKey = this.getDelegateProperty('contentValueKey', del) ;
+    if (valueKey && (key === valueKey || key === '*')) {
+      this.set('value', content ? content.get(valueKey) : null) ;
+    }
+
+    var titleKey = this.getDelegateProperty('contentTitleKey', del) ;
+    if (titleKey && (key === titleKey || key === '*')) {
+      this.set('title', content ? content.get(titleKey) : null) ;
+    }
+
+    var iconKey = this.getDelegateProperty('contentIconKey', del);
+    if (iconKey && (key === iconKey || key === '*')) {
+      this.set('icon', content ? content.get(iconKey) : null) ;
+    }
+  },
+
+  /** @private - when title changes, dirty display. */
+  _button_displayObserver: function() {
+    this.displayDidChange();
+  }.observes('title', 'icon', 'value'),
+
+  /**
+    The key equivalent that should trigger this button on the page.
+  */
+  keyEquivalent: null,
+  
+  /**
+    Handle a key equivalent if set.  Trigger the default action for the 
+    button.  Depending on the implementation this may vary.
+    
+    @param {String} keystring
+    @param {SC.Event} evt
+    @returns {Boolean}  YES if handled, NO otherwise
+  */
+  performKeyEquivalent: function(keystring, evt) {
+    if (!this.get('isEnabled')) return NO;
+    var keyEquivalent = this.get('keyEquivalent');
+    if (keyEquivalent && (keyEquivalent === keystring)) {
+      // button has defined a keyEquivalent and it matches!
+      // if triggering succeeded, true will be returned and the operation will 
+      // be handeled (i.e performKeyEquivalent will cease crawling the view 
+      // tree)
+      return this.triggerAction(evt);
+    }
+    return NO; // did not handle it; keep searching
+  },
+
+  /**
+    Your class should implement this method to perform the default action on
+    the button.  This is used to implement keyboard control.  Your button
+    may make this change in its own way also.
+  */
+  triggerAction: function(evt) {
+    throw "SC.Button.triggerAction() is not defined in %@".fmt(this);
+  },
+
+  // ..........................................................
+  // VALUE <-> isSelected STATE MANAGEMNT
+  // 
+
+  /**
+    This is the standard logic to compute a proposed isSelected state for a
+    new value.  This takes into account the toggleOnValue/toggleOffValue 
+    properties, among other things.  It may return YES, NO, or SC.MIXED_STATE.
+    
+    @param {Object} value
+    @returns {Boolean} return state
+  */
+  computeIsSelectedForValue: function(value) {
+    var targetValue = this.get('toggleOnValue') ;
+    var state, next ;
+    
+    if (SC.typeOf(value) === SC.T_ARRAY) {
+
+      // treat a single item array like a single value
+      if (value.length === 1) {
+        state = (value[0] == targetValue) ;
+        
+      // for a multiple item array, check the states of all items.
+      } else {
+        state = null;
+        value.find(function(x) {
+          next = (x == targetValue) ;
+          if (state === null) {
+            state = next ;
+          } else if (next !== state) state = SC.MIXED_STATE ;
+          return state === SC.MIXED_STATE ; // stop when we hit a mixed state.
+        });
+      }
+      
+    // for single values, just compare to the toggleOnValue...use truthiness
+    } else {
+      state = (value == targetValue) ;
+    }
+    return state ;
+  },
+  
+  initMixin: function() {
+    // if value is not null, update isSelected to match value.  If value is
+    // null, we assume you may be using isSelected only.  
+    if (!SC.none(this.get('value'))) this._button_valueDidChange();  
+  },
+  
+  /** @private
+    Whenever the button value changes, update the selected state to match.
+  */
+  _button_valueDidChange: function() {
+    var value = this.get('value');  
+    var state = this.computeIsSelectedForValue(value);
+    this.set('isSelected', state) ; // set new state...
+  }.observes('value'),
+  
+  /** @private
+    Whenever the selected state is changed, make sure the button value is also updated.  Note that this may be called because the value has just changed.  In that case this should do nothing.
+  */
+  _button_isSelectedDidChange: function() {
+    var newState = this.get('isSelected');
+    var curState = this.computeIsSelectedForValue(this.get('value'));
+    
+    // fix up the value, but only if computed state does not match.
+    // never fix up value if isSelected is set to MIXED_STATE since this can
+    // only come from the value.
+    if ((newState !== SC.MIXED_STATE) && (curState !== newState)) {
+      var valueKey = (newState) ? 'toggleOnValue' : 'toggleOffValue' ;
+      this.set('value', this.get(valueKey));
+    }
+  }.observes('isSelected')
+  
+} ;