sproutcore 0.9.0

data/frameworks/sproutcore/foundation/responder.js

@@ -0,0 +1,310 @@
+// ========================================================================
+// SproutCore
+// copyright 2006-2007 Sprout Systems, Inc.
+// ========================================================================
+
+require('Core') ;
+require('foundation/object') ;
+require('foundation/input_manager');
+
+/**
+  @class A responder is capable of responding to events such as mouse clicks and key presses.  
+  
+  All views are a type of responder, but you can extend this class yourself 
+  as well to implement your own responders if you need to.
+  
+  @extends SC.Object
+  
+*/
+SC.Responder = SC.Object.extend(
+  /** @scope SC.Responder.prototype */
+  {
+    
+  // .......................................................................
+  // Managing Responder States
+  //
+  
+  /**  
+    This method will be called just before you become first responder to see
+    if you want to be first responder.  If you don't want to handle
+    keyboard events, return false. (this is the default).  Note that this is
+    a property.
+  */
+  acceptsFirstResponder: false,
+  
+  /**
+    This property is the next responder that should be allowed to handle
+    events if you don't want to handle it.  For views, this is automatically
+    set to your parentNode.
+  */
+  nextResponder: null,
+  
+  /**  
+    This property is true whenever you are the first responder.  Observable.
+  */
+  isFirstResponder: false,
+
+  pane: null,
+  
+  /**
+    Call this method to become the first responder.  You will now be the
+    first to receive keyboard events, etc.  Return false if you could not
+    be made first responder for some reason.
+  */
+  becomeFirstResponder: function()
+  {
+    if (!this.get('acceptsFirstResponder')) return false; // responder doesn't want it
+
+    var pane = this.get('pane');
+    if (!pane) return false;                              // there's no pane of which to become FR.. doesn't matter if it *does* want it...
+
+    if (pane.get('firstResponder') == this) return true;  // we already got it... and setting it again will trigger the willResign callback
+
+    pane.set('firstResponder',this);
+    return true;
+  },
+  
+  /**
+    Call this method if you no longer want to be first responder.  Normally
+    you don't need to do this since you will lose firstResponder status
+    when the user focuses a different view.
+  */
+  resignFirstResponder: function()
+  {
+    var pane = this.get('pane');
+    if (!pane) return false;
+    
+    if (pane.get('firstResponder') != this) return false;
+    
+    pane.set('firstResponder',null);
+    return true;
+  },
+  
+  noResponderFor: function() {},
+  
+  /**
+    This method will be called just before you become the first responder
+    so you can make changes.
+  */
+  didBecomeFirstResponder: function() {},
+  
+  /**
+    This method will be called just before you lose first responder status.
+  */
+  willLoseFirstResponder: function() {},
+
+
+  // .......................................................................
+  // Keyboard Events
+  //
+  
+  /**
+    Set this value to an SC.InputManager instance if you want to use a 
+    custom input manager for this specific instance.  If you want to override
+    the input manager used for all responders, replace SC.Responder.inputManager.
+  */
+  inputManager: function()
+  {
+    return SC.Responder.inputManager;
+  }.property(),
+
+  /**
+    this method is invoked on the firstResponder whenever the user presses
+    a key.  You can interpret this yourself or call interpretKeyEvents()
+    which will use the inputManager to handle the event.  The default
+    version just passes this onto the next responder.
+  */
+  keyDown: function(evt) {
+    var nr = this.get('nextResponder') ;
+    return (nr && nr.keyDown) ? nr.keyDown(evt) : false;
+  },
+  
+  /**  
+    This method is invoked on the firstResponder whenever the user releases
+    a key.  Default version just passes onto the next responder.
+  */
+  keyUp: function(evt) {
+    var nr = this.get('nextResponder') ;
+    return (nr && nr.keyUp) ? nr.keyUp(evt) : false ;
+  },
+  
+  /**  
+    This method is invoked whenever the user changes the flag keys that are
+    pressed.  pressedFlags is a hash.  The default version passes on to the
+    nextRespoonder.
+  */
+  flagsChanged: function(pressedFlags, evt) {
+    //var nr = this.get('nextResponder') || SC.window.get('firstResponder') ;
+    var nr = this.get('nextResponder') ;
+    return (nr && nr.flagsChanges) ? nr.flagsChanges(pressedFlags, evt) : false;
+  },
+
+  /**
+    This will be called if a keydown event isn't handled by the responder chain.
+  */
+  performKeyEquivalent: function(keystring, evt) {
+    return false;
+  },
+
+  /*
+    call this method with one or more event objects to process the incoming
+    text.  This will use the current inputManager (see above) to process
+    the event and then to make an appropriate call on the receiver.
+  */
+  interpretKeyEvents: function(evts) {
+    var inputManager = this.get('inputManager');
+    if (inputManager) return inputManager.interpretKeyEvents(evts, this) ;
+    return false ;
+  },
+
+  /**
+  * Attempt to perform a method. If either the method does not exist, or the method returns false, send the request to the nextResponder.
+  * @param {String} method The name of the method to perform
+  * @return {SC.Responder} The responder that handled the command, or false
+  */
+  doCommand: function(method)
+  {
+    var responder = this;
+    var args      = $A(arguments);
+    var method    = args.shift();
+    var aliases   = this._commandAliases[method];
+    var handled   = false;
+    
+    do {
+      // attempt to handle the method
+      if (this._responderHandledCommand(responder, method, args)) return responder;
+      // perhaps under an alias?
+      if (aliases)
+      {
+        for (var i=0, n=aliases.length; i < n; i++)
+        {
+          if (this._responderHandledCommand(responder, aliases[i], args)) return responder;
+        }
+      }
+      // nope... next responder, please...
+    } while (responder = responder.get('nextResponder'));
+    // ran out of responders... 
+    return false;
+  },
+  
+  /** @private */
+  _responderHandledCommand: function( responder, method, args )
+  {
+    // if the method does not explicitly return a false-y value (false, "", 0), it's considered "handled"
+    // WARNING: returning null, or void is *not* == false
+    return (responder.respondsTo(method) && (responder[method].apply(responder, args) != false));
+  },
+  /** @private */
+  _commandAliases: {
+    'mouseDown':   ['didMouseDown'],
+    'mouseUp':     ['didMouseUp'],
+    'doubleClick': ['didDoubleClick'],
+    'click':       ['didClick'],
+    'mouseDown':   ['didMouseDown']
+  }
+
+  // .......................................................................
+  // Mouse Event Handlers
+  //
+  // Implement any of these if you want them to be implemented.
+  
+  // when the mouse is pressed.
+  // mouseDown: function(evt) {},
+  
+  // when the mouse is releases
+  // mouseUp: function(evt) {},
+  
+  // when the mouse is dragged
+  // mouseDragged: function(evt) {},
+  
+  // when the mouse leaves the view responder
+  // mouseOut: function(evt) {},
+  
+  // when the mouse enters the view.
+  // mouseOver: function(evt) {},
+  
+  // when the mouse is moved.
+  // mouseMoved: function(evt) {},
+  
+  // .......................................................................
+  // Event Handlers
+  //
+  // These methods are called by the input manager in response to keyboard
+  // events.  Most of these methods are defined here for you, but not actually
+  // implemented in code.
+
+  // insert the text or act on the key.
+  // insertText: function(text) {},
+  
+  // if the user presses a key-combination event, this will be called so you
+  // can run the command. 
+  // performKeyEquivalent: function(charCode, evt) { return false; },
+  
+  // this method is called if no other view in the current view hierarchy is
+  // bound to the escape or command-. key equivalent.  You can use this to 
+  // cancel whatever operation is running.
+  //
+  // cancel: function(sender, evt) {},
+
+  // delete the current selection or delete one element backward from the
+  // current selection.
+  // deleteBackward: function(sender, evt) {},
+  
+  // delete the current selection or delete one element forward from the
+  // current selection.
+  // deleteForward: function(sender, evt) {},
+  
+  // a field editor might respond by selecting the field before it.
+  // insertBacktab: function(sender, evt) {},
+  
+  // insert a newline character or end editing of the receiver.
+  // insertNewline: function(sender, evt) {},
+  
+  // insert a tab or move forward to the next field.
+  // insertTab: function(sender, evt) {},
+  
+  // move insertion point/selection backward one. (i.e. left arrow key)
+  // moveLeft: function(sender, evt) {},
+  
+  // move the insertion point/selection forward one (i.e. right arrow key)
+  // in left-to-right text, this could be the left arrow key.
+  // moveRight: function(sender, evt) {},
+  
+  // move the insertion point/selection up one (i.e. up arrow key)
+  // moveUp: function(sender, evt) {},
+  
+  // move the insertion point/selection down one (i.e. down arrow key)
+  // moveDown: function(sender, evt) {},
+  
+  // move left, extending the selection. - shift || alt
+  // moveLeftAndModifySelection: function(sender, evt) {},
+  
+  // move right, extending the seleciton - shift || alt
+  // moveRightAndModifySelection: function(sender, evt) {},
+  
+  // move up, extending the selection - shift || alt
+  // moveUpAndModifySelection: function(sender, evt) {},
+  
+  // move down, extending selection - shift || alt
+  // moveDownAndModifySelection: function(sender, evt) {},
+  
+  // move insertion point/selection to beginning of document.
+  // moveToBeginningOfDocument: function(sender, evt) {},
+  
+  // move insertion point/selection to end of document.
+  // moveToEndOfDocument: function(sender, evt) {},
+  
+  // page down
+  // pageDown: function(sender, evt) {},
+  
+  // page up
+  // pageUp: function(sender, evt) {},
+  
+  // select all
+  // selectAll: function(sender, evt) {},
+  
+});
+
+SC.Responder.mixin({
+  inputManager: SC.InputManager.create()
+}) ;

data/frameworks/sproutcore/foundation/routes.js

@@ -0,0 +1,371 @@
+// ========================================================================
+// SproutCore
+// copyright 2006-2007 Sprout Systems, Inc.
+// ========================================================================
+
+require('foundation/object') ;
+
+// Routes makes it possible to load a location in the browser.
+SC.Routes = SC.Object.create({
+
+  // set this property to your current app lication
+  location: function(key,value) {
+    if (value !== undefined) {
+      if (value === null) value = '' ;
+      
+      // convert an object hash to a string, if it was passed.
+      if (typeof(value) == "object") {
+
+        // get the original route and any params
+        var parts = (value.route) ? value.route.split('&') : [''] ;
+        var route = parts.shift() ;
+        var params = {} ;
+        parts.each(function(p) {
+          var bits = p.split('=') ;
+          params[bits[0]] = bits[1] ;
+        }) ;
+
+        // overlay any params passed in the object.
+        for(var key in value) {
+          if (!value.hasOwnProperty(key)) continue ;
+          if (key != 'route') {
+            params[key] = encodeURIComponent(''+value[key]) ;
+          }
+        }
+        
+        // now build params.
+        parts = [route] ;
+        for(var key in params) {
+          if (!params.hasOwnProperty(key)) continue ;
+          parts.push([key,params[key]].join('=')) ;          
+        }
+        
+        // and combine.
+        value = parts.join('&') ;
+      }
+      
+      if (this._location != value) {
+        this._location = value ;
+        this._setWindowLocation(value) ;
+        //this.gotoRoute(value) ;
+      }
+    }
+    return this._location ;
+  }.property(),
+  
+  // ensures we are at the current route location.
+  ping: function() { 
+    if (!this._didSetupHistory) {
+      this._didSetupHistory = true ;
+      this._setupHistory() ;
+    }
+    this._checkWindowLocation(); 
+  },
+  
+  // register a route here.  Routes have the following format:
+  // static/route/path -- matches this path only.
+  // static/route/:path -- matches any static/route, :path passed as param.
+  // static/*route -- matches any static, route gets rest of URL.
+  //
+  // parameters can also be passed using &.
+  // static/route&param1=value&param2=value2
+  //
+  addRoute: function(route, func) {
+    var parts = route.split('/') ;
+    if (!this._routes) this._routes = SC.Routes._Route.create() ;
+    this._routes.addRoute(parts,func) ;
+  },
+  
+  // eval routes.
+  gotoRoute: function(route) {
+    var params = {} ; var parts, route, func ;
+
+    // save this route for window location sensing
+    this._lastRoute = route ;
+    
+    // step 1: split out parameters
+    var parts = route.split('&') ;
+    if (parts && parts.length > 0) {
+      route = parts.shift() ;
+      parts.each(function(part) {
+        var param = part.split('=') ;
+        if (param && param.length > 1) params[param[0]] = decodeURIComponent(param[1]) ;
+      }) ;
+    } else route = '' ;
+    
+    // step 2: split our route parts
+    parts = route.split('/') ;
+    
+    // step 3: evaluate route.
+    if (!this._routes) this._routes = SC.Routes._Route.create() ;
+    func = this._routes.functionForRoute(parts,params) ;
+    if (func) func(params) ;
+    else console.log('could not find route for: "'+route+'"') ;
+  },
+  
+  
+  init: function() {
+    arguments.callee.base.call(this) ;
+    if (SC.isSafari() && !SC.isSafari3()) {
+      Object.extend(this,this.browserFuncs.safari) ;  
+    } else if (SC.isIE()) {
+      Object.extend(this,this.browserFuncs.ie) ;  
+    }
+    this._didSetupHistory = false ;
+  },
+  
+  // _checkWindowLocation and _setWindowLocation are implemented separately for
+  // each browser.  Below are the implementations, which get copied during init.
+  browserFuncs: {
+    
+    // for Safari2 and earlier.
+    safari: {
+
+      _setupHistory: function() {
+        // get initial cloc.
+        var cloc = location.hash ;
+        cloc = (cloc && cloc.length > 0) ? cloc.slice(1,cloc.length) : '' ;
+        this._cloc = cloc ;
+
+        // create back stack.
+        this._backStack = [] ;
+        this._backStack.length = history.length ;
+        this._backStack.push(cloc) ;
+
+        // create forward stack.
+        this._forwardStack = [] ;
+
+        this._boundChecker = this._checkWindowLocation.bind(this) ;
+        this.timer = setTimeout(this._boundChecker,1000) ;
+      },
+      
+      _checkWindowLocation: function() { 
+        // The way we know the user has moved forward or back in the history 
+        // is when the length of the history array no longer matched our own 
+        // copy of the history. However, when we first change locations, it 
+        // takes a little while for Safari to catch up.  So what we do instead 
+        // is first check to see if Safari's length has changed from its last 
+        // known length and only then check for a delta.
+        var historyDidChange = (history.length - this._lastLength) != 0;
+        var delta = (historyDidChange) ? (history.length - this._backStack.length) : 0 ;
+        this._lastLength = history.length ;
+
+        if (historyDidChange) console.log('historyDidChange') ;
+        
+        // if the history length has changed, then we need to move forward or 
+        // back in the history.
+        if (delta) {
+          if (delta < 0) { // back button has been pushed
+            
+            // shift out the current loc.
+            this._forwardStack.push(this._cloc) ; 
+            
+            // shift out other items.
+            for(var i=0; i < Math.abs(delta+1);i++) {
+              this._forwardStack.push(this._backStack.pop()) ;
+            }
+            
+            // set new cloc.
+            this._cloc = this._backStack.pop() ;
+            
+            
+          } else { // forward button has been pushed
+            
+            // shift out the current loc.
+            this._backStack.push(this._cloc) ;
+            
+            for(var i=0; i < (delta-1); i++) {
+              this._backStack.push(this._forwardStack.pop()) ;
+            }
+            
+            this._cloc = this._forwardStack.pop() ;
+          }
+
+        // if the history has changed but the delta hasn't, then that means
+        // a new location was set via _setWindowLocation().  Normally we would
+        // call gotoRoute in that method, but doing so will crash Safari.
+        // Instead, we wait until Safari registers the change and then do the
+        // route change.
+        } else if (historyDidChange && this._locationDidChange) {
+          this.gotoRoute(this._cloc) ;
+          this._locationDidChange = false ;
+        }
+
+        var cloc = this._cloc ;
+        var loc = this.get('location') ;
+        if (cloc != loc) {
+          this.set('location',(cloc) ? cloc : '') ;
+          this.gotoRoute(cloc) ;
+        }
+        
+        this.timer = setTimeout(this._boundChecker,50) ; 
+      },
+
+      _setWindowLocation: function(loc) {        
+        var cloc = this._cloc ;
+        if (cloc != loc) {
+          this._backStack.push(this._cloc) ;
+          this._forwardStack.length = 0 ;
+          this._cloc = loc ;          
+          location.hash = (loc && loc.length > 0) ? loc : '' ;
+          this._locationDidChange = true ;
+        }
+      }            
+      
+    },
+    
+    // for IE.
+    ie: {
+      _setupHistory: function() {
+        this._boundChecker = this._checkWindowLocation.bind(this) ;
+//        this.timer = setTimeout(this._boundChecker,1000) ;
+      },
+
+      _checkWindowLocation: function() {
+        var loc = this.get('location') ;
+        var cloc = location.hash ;
+        cloc = (cloc && cloc.length > 0) ? cloc.slice(1,cloc.length) : '' ;
+        if (cloc != loc) this.set('location',(cloc) ? cloc : '') ;
+        this.timer = setTimeout(this._boundChecker,100) ;
+      },
+
+      _setWindowLocation: function(loc) {
+        //console.log('_setWindowLocation('+loc+')') ;
+        var cloc = location.hash ;
+        cloc = (cloc && cloc.length > 0) ? cloc.slice(1,cloc.length) : '' ;
+        if (cloc != loc) {
+          location.hash = (loc && loc.length > 0) ? loc : '#' ;
+        }
+        this.gotoRoute(loc) ;
+      }
+    }
+  },
+  
+  _setupHistory: function() {
+    this._boundChecker = this._checkWindowLocation.bind(this) ;
+    this.timer = setTimeout(this._boundChecker,1000) ;
+  },
+  
+  _checkWindowLocation: function() {
+    var loc = this.get('location') ;
+    var cloc = location.hash ;
+    cloc = (cloc && cloc.length > 0) ? cloc.slice(1,cloc.length) : '' ;
+    if (cloc != loc) this.set('location',(cloc) ? cloc : '') ;
+    this.timer = setTimeout(this._boundChecker,100) ;
+  },
+  
+  _setWindowLocation: function(loc) {
+    //console.log('_setWindowLocation('+loc+')') ;
+    var cloc = location.hash ;
+    cloc = (cloc && cloc.length > 0) ? cloc.slice(1,cloc.length) : '' ;
+    if (cloc != loc) {
+      location.hash = (loc && loc.length > 0) ? loc : '#' ;
+    }
+    this.gotoRoute(loc) ;
+  },
+  
+  _routes: null,
+  
+  // This object handles a single route level.  
+  _Route: SC.Object.extend({
+    
+    // a route that ends here gets this func.
+    _func: null,
+    
+    // staticly named routes.
+    _static: null,
+    
+    // dynamically named routes.
+    _dynamic: null,
+    
+    // set the wildcard route name here.
+    _wildcard: null,
+    
+    addRoute: function(parts, func) {
+      if (!parts || parts.length == 0) {
+        this._func = func ;
+        
+      // add to route table.
+      } else {
+        var part = parts.shift() ; // get next route.
+        var nextRoute = null ;
+        switch(part.slice(0,1)) {
+          
+          // add a dynamic route
+          case ':':
+            part = part.slice(1,part.length) ;
+            var routes = this._dynamic[part] || [] ;
+            nextRoute = SC.Routes._Route.create() ;
+            routes.push(nextRoute) ;
+            this._dynamic[part] = routes ;
+            break ;
+            
+          // setup wildcard route
+          case '*':
+            part = part.slice(1,part.length) ;
+            this._wildcard = part ;
+            this._func = func ;
+            break ;
+            
+          // setup a normal static route.
+          default:
+            var routes = this._static[part] || [] ;
+            nextRoute = SC.Routes._Route.create() ;
+            routes.push(nextRoute) ;
+            this._static[part] = routes ;
+        }
+        
+        // if we need to go another level deeper, call nextRoute
+        if (nextRoute) nextRoute.addRoute(parts,func) ;
+      }
+    },
+    
+    // process the next level of the route and pass on.
+    functionForRoute: function(parts, params) {
+      // if parts it empty, then we are here, so return func
+      if (!parts || parts.length == 0) {
+        return this._func ;
+        
+      // process the next part
+      } else {
+        var part = parts.shift() ;
+        var routes, nextRoute, ret, loc ;
+        
+        // try to match to static
+        routes = this._static[part] ;
+        if (routes) for(loc=0;(loc < routes.length) && (ret==null);loc++) {
+          var clone = parts.slice() ;
+          ret = routes[loc].functionForRoute(clone, params) ;
+        }
+        
+        // try to match dynamic if no static match was found.
+        if (ret == null) for(var key in this._dynamic) {
+          routes = this._dynamic[key] ;
+          if (routes) for(loc=0;(loc<routes.length) && (ret == null);loc++) {
+            var clone = parts.slice() ;
+            ret = routes[loc].functionForRoute(clone,params) ;
+            
+            // if a route was found, save the current part in params.
+            if (ret && params) params[key] = part ;
+          }
+          if (ret) break ; 
+        }
+        
+        // if nothing still found, and there is a wildcard, match that.
+        if ((ret == null) && this._wildcard) {
+          parts.unshift(part) ;
+          if (params) params[this._wildcard] = parts.join('/') ;
+          ret = this._func ;
+        }
+        
+        return ret ;
+      }
+    },
+    
+    init: function() {
+      arguments.callee.base.call(this) ;
+      this._static = {} ; this._dynamic = {} ;
+    }
+  })
+  
+}) ;

data/frameworks/sproutcore/foundation/run_loop.js

@@ -0,0 +1,21 @@
+// ========================================================================
+// SproutCore
+// copyright 2006-2007 Sprout Systems, Inc.
+// ========================================================================
+
+require('Core') ;
+
+// RunLoop is used to manage deferred runs.  It's lighter weight than setting
+// lots of timeouts.
+SC.runLoop = SC.Object.create({
+  
+  schedule: function() {
+    var args = $A(arguments) ; 
+    var obj = args.shift() ; 
+    var method = obj[args.shift()];
+    var delay = args.pop() ;
+    var func = function() { method.apply(obj, args); }
+    return setTimeout(func, delay) ;  
+  }
+  
+}) ;