RubyGems - sproutit-sproutcore - Versions diffs - 1.0.203 → 1.0.20090721145236 - Mend

sproutit-sproutcore 1.0.203 → 1.0.20090721145236

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (933) hide show

data/frameworks/sproutcore/frameworks/foundation/system/responder_context.js DELETED Viewed

@@ -1,243 +0,0 @@
-// ==========================================================================
-// 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)
-// ==========================================================================
-sc_require('system/responder');
-/** @class
-  The root object for a responder chain.  A responder context can dispatch
-  actions directly to a first responder; walking up the responder chain until
-  it finds a responder that can handle the action.
-  If no responder can be found to handle the action, it will attempt to send
-  the action to the defaultResponder.
-  You can have as many ResponderContext's as you want within your application.
-  Every SC.Pane and SC.Application automatically implements this mixin.
-  Note that to implement this you must be a responder yourself.
-  @extends SC.Responder
-  @since SproutCore 1.0
-*/
-SC.ResponderContext = SC.Responder.extend({
-  // ..........................................................
-  // PROPERTIES
-  //
-  isResponderContext: YES,
-  /** @property
-    When set to YES, logs tracing information about all actions sent and
-    responder changes.
-  */
-  trace: NO,
-  /** @property
-    The default responder.  Set this to point to a responder object that can
-    respond to events when no other view in the hierarchy handles them.
-    You can also implement actions directly on the application object if you
-    prefer.
-  */
-  defaultResponder: null,
-  /** @property
-    The next responder for an app is always its defaultResponder.
-  */
-  nextResponder: function() {
-    return this.get('defaultResponder');
-  }.property('defaultResponder').cacheable(),
-  /** @property
-    The first responder.  This is the first responder that should receive
-    actions.
-  */
-  firstResponder: null,
-  // ..........................................................
-  // METHODS
-  //
-  /**
-    Finds the next responder for the passed responder based on the responder's
-    nextResponder property.  If the property is a string, then lookup the path
-    in the receiver.
-  */
-  nextResponderFor: function(responder) {
-    var next = responder.get('nextResponder');
-    if (typeof next === SC.T_STRING) {
-      next = SC.objectForPropertyPath(next, this);
-    } else if (!next && (responder !== this)) next = this ;
-    return next ;
-  },
-  /**
-    Finds the responder name by searching the responders one time.
-  */
-  responderNameFor: function(responder) {
-    if (!responder) return "(No Responder)";
-    else if (responder._scrc_name) return responder._scrc_name;
-    // none found, let's go hunting...look three levels deep
-    var n = this.NAMESPACE;
-    this._findResponderNamesFor(this, 3, n ? [this.NAMESPACE] : []);
-    return responder._scrc_name || responder.toString(); // try again
-  },
-  _findResponderNamesFor: function(responder, level, path) {
-    var key, value;
-    for(key in responder) {
-      if (key === 'nextResponder') continue ;
-      value = responder[key];
-      if (value && value.isResponder) {
-        if (value._scrc_name) continue ;
-        path.push(key);
-        value._scrc_name = path.join('.');
-        if (level>0) this._findResponderNamesFor(value, level-1, path);
-        path.pop();
-      }
-    }
-  },
-  /**
-    Makes the passed responder into the new firstResponder for this
-    responder context.  This will cause the current first responder to lose
-    its responder status and possibly keyResponder status as well.
-    When you change the first responder, this will send callbacks to
-    responders up the chain until you reach a shared responder, at which point
-    it will stop notifying.
-    @param {SC.Responder} responder
-    @returns {SC.ResponderContext} receiver
-  */
-  makeFirstResponder: function(responder) {
-    var current = this.get('firstResponder'),
-        last    = this.get('nextResponder'),
-        trace   = this.get('trace'),
-        common ;
-    if (this._locked) {
-      if (trace) {
-        console.log('%@: AFTER ACTION: makeFirstResponder => %@'.fmt(this, this.responderNameFor(responder)));
-      }
-      this._pendingResponder = responder;
-      return ;
-    }
-    if (trace) {
-      console.log('%@: makeFirstResponder => %@'.fmt(this, this.responderNameFor(responder)));
-    }
-    this._locked = YES;
-    this._pendingResponder = null;
-    // Find the nearest common responder in the responder chain for the new
-    // responder.  If there are no common responders, use last responder.
-    common = responder ? this.nextResponderFor(responder) : null;
-    while (common) {
-      if (common.get('hasFirstResponder')) break;
-      common = (common===last) ? null : this.nextResponderFor(common);
-    }
-    if (!common) common = last;
-    // Cleanup old first responder
-    this._notifyWillLoseFirstResponder(current, current, common);
-    if (current) current.set('isFirstResponder', NO);
-    // Set new first responder.  If new firstResponder does not have its
-    // responderContext property set, then set it.
-    this.set('firstResponder', responder) ;
-    if (responder) responder.set('isFirstResponder', YES);
-    this._notifyDidBecomeFirstResponder(responder, responder, common);
-    this._locked = NO ;
-    if (responder = this._pendingResponder) {
-      this._pendingResponder= null ;
-      this.makeFirstResponder(this._pendingResponder);
-    }
-    return this ;
-  },
-  _notifyWillLoseFirstResponder: function(responder, cur, root) {
-    if (cur === root) return ; // nothing to do
-    cur.willLoseFirstResponder(responder);
-    cur.set('hasFirstResponder', NO);
-    var next = this.nextResponderFor(cur);
-    if (next) this._notifyWillLoseFirstResponder(responder, next, root);
-  },
-  _notifyDidBecomeFirstResponder: function(responder, cur, root) {
-    if (cur === root) return ; // nothing to do
-    var next = this.nextResponderFor(cur);
-    if (next) this._notifyDidBecomeFirstResponder(responder, next, root);
-    cur.set('hasFirstResponder', YES);
-    cur.didBecomeFirstResponder(responder);
-  },
-  /**
-    Send the passed action down the responder chain, starting with the
-    current first responder.  This will look for the first responder that
-    actually implements the action method and returns YES or no value when
-    called.
-    @param {String} action name of action
-    @param {Object} sender object sending the action
-    @param {Object} context optional additonal context info
-    @returns {SC.Responder} the responder that handled it or null
-  */
-  sendAction: function(action, sender, context) {
-    var working = this.get('firstResponder'),
-        last    = this.get('nextResponder'),
-        trace   = this.get('trace'),
-        handled = NO,
-        responder;
-    this._locked = YES;
-    if (trace) {
-      console.log("%@: begin action '%@' (%@, %@)".fmt(this, action, sender, context));
-    }
-    while (!handled && working) {
-      if (working.tryToPerform) {
-        handled = working.tryToPerform(action, sender, context);
-      }
-      if (!handled) {
-        working = (working===last) ? null : this.nextResponderFor(working);
-      }
-    }
-    if (trace) {
-      if (!handled) console.log("%@:  action '%@' NOT HANDLED".fmt(this,action));
-      else console.log("%@: action '%@' handled by %@".fmt(this, action, this.responderNameFor(working)));
-    }
-    this._locked = NO ;
-    if (responder = this._pendingResponder) {
-      this._pendingResponder= null ;
-      this.makeFirstResponder(responder);
-    }
-    return working ;
-  }
-});

data/frameworks/sproutcore/frameworks/foundation/system/root_responder.js DELETED Viewed

@@ -1,391 +0,0 @@
-// ==========================================================================
-// 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)
-// ==========================================================================
-require('system/ready');
-/** @class
-  The RootResponder captures events coming from a web browser and routes them
-  to the correct view in the view hierarchy.  Usually you do not work with a
-  RootResponder directly.  Instead you will work with Pane objects, which
-  register themselves with the RootResponder as needed to receive events.
-  h1. RootResponder and Platforms
-  RootResponder is implemented differently on the desktop and mobile platforms
-  using a technique called a "class cluster".  That is, although you get a
-  RootResponder instance at some point, you will likely be working with a
-  subclass of RootResponder that implements functionality unique to that
-  platform.
-  The RootResponder you use depends on the active platform you have set and
-  the framework you have loaded.
-  h1. Event Types
-  RootResponders can route four types of events:
-  - Direct events.  Such as mouse and touch events.  These are routed to the
-    nearest view managing the target DOM elment.
-  - Keyboard events.  These are sent to the keyPane, which will send it
-    to the current firstResponder.
-  - resize. This event is sent to all panes.
-  - shortcuts.  Shortcuts are sent to the focusedPane first, which will go
-    down its view hierarchy.  Then they go to the mainPane, which will go down
-    its view hierarchy.  Then they go to the mainMenu.  Usually any handler
-    that picks this up will then try to do a sendAction().
-  - actions.  Actions are sent down the responder chain.  They go to
-    focusedPane -> mainPane.  Each of these will start at the firstResponder
-    and work their way up the chain.
-  Differences between Mobile + Desktop RootResponder
-  The Desktop root responder can deal with the following kinds of events:
-   mousedown, mouseup, mouseover, mouseout, mousemoved
-*/
-SC.RootResponder = SC.Object.extend({
-  /**
-    Contains a list of all panes currently visible on screen.  Everytime a
-    pane attaches or detaches, it will update itself in this array.
-  */
-  panes: null,
-  init: function() {
-    sc_super();
-    this.panes = SC.Set.create();
-  },
-  // .......................................................
-  // MAIN Pane
-  //
-  /** @property
-    The main pane.  This pane receives shortcuts and actions if the
-    focusedPane does not respond to them.  There can be only one main pane.
-    You can swap main panes by calling makeMainPane() here.
-    Usually you will not need to edit the main pane directly.  Instead, you
-    should use a MainPane subclass, which will automatically make itself main
-    when you append it to the document.
-  */
-  mainPane: null,
-  /**
-    Swaps the main pane.  If the current main pane is also the key pane, then
-    the new main pane will also be made key view automatically.  In addition
-    to simply updating the mainPane property, this method will also notify the
-    panes themselves that they will lose/gain their mainView status.
-    Note that this method does not actually change the Pane's place in the
-    document body.  That will be handled by the Pane itself.
-    @param {SC.Pane} pane
-    @returns {SC.RootResponder} receiver
-  */
-  makeMainPane: function(pane) {
-    var currentMain = this.get('mainPane') ;
-    if (currentMain === pane) return this ; // nothing to do
-    this.beginPropertyChanges() ;
-    // change key focus if needed.
-    if (this.get('keyPane') === currentMain) this.makeKeyPane(pane) ;
-    // change setting
-    this.set('mainPane', pane) ;
-    // notify panes.  This will allow them to remove themselves.
-    if (currentMain) currentMain.blurMainTo(pane) ;
-    if (pane) pane.focusMainFrom(currentMain) ;
-    this.endPropertyChanges() ;
-    return this ;
-  },
-  // .......................................................
-  // KEY ROOT VIEW
-  //
-  /** @property
-    The current key pane.  This pane receives keyboard events, shortcuts, and
-    actions first.  This pane is usually the highest ordered pane or the
-    mainPane.
-  */
-  keyPane: null,
-  /**
-    Makes the passed pane the new key pane.  If you pass nil or if the pane
-    does not accept key focus, then key focus will transfer to the mainPane.
-    This will notify both the old pane and the new root View that key focus
-    has changed.
-    @param {SC.Pane} pane
-    @returns {SC.RootResponder} receiver
-  */
-  makeKeyPane: function(pane) {
-    if (pane && !pane.get('acceptsKeyPane')) return this ;
-    // if null was passed, try to make mainPane key instead.
-    if (!pane) {
-      pane = this.get('mainPane') ;
-      if (pane && !pane.get('acceptsKeyPane')) pane = null ;
-    }
-    var current = this.get('keyPane') ;
-    if (current === pane) return this ; // nothing to do
-    // now notify old and new key views of change after edit
-    if (current) current.willLoseKeyPaneTo(pane) ;
-    if (pane) pane.willBecomeKeyPaneFrom(current) ;
-    this.set('keyPane', pane) ;
-    if (pane) pane.didBecomeKeyPaneFrom(current) ;
-    if (current) current.didLoseKeyPaneTo(pane) ;
-    return this ;
-  },
-  /**
-    Overridden by subclasses to return the window size.  The default simply
-    returns 640 x 480.
-    @returns {Size} the size of the window in pixels
-  */
-  computeWindowSize: function() {
-    return { width: 640, height: 480 } ;
-  },
-  // .......................................................
-  // ACTIONS
-  //
-  /** @property
-    Set this to a delegate object that can respond to actions as they are sent
-    down the responder chain.
-  */
-  defaultResponder: null,
-  /**
-    Route an action message to the appropriate responder.  This method will
-    walk the responder chain, attempting to find a responder that implements
-    the action name you pass to this method.  Set 'tagret' to null to search
-    the responder chain.
-    IMPORTANT: This method's API and implementation will likely change
-    significantly after SproutCore 1.0 to match the version found in
-    SC.ResponderContext.
-    You generally should not call or override this method in your own
-    applications.
-    @param {String} action The action to perform - this is a method name.
-    @param {SC.Responder} target object to set method to (can be null)
-    @param {Object} sender The sender of the action
-    @param {SC.Pane} pane optional pane to start search with
-    @param {Object} context optional. only passed to ResponderContexts
-    @returns {Boolean} YES if action was performed, NO otherwise
-    @test in targetForAction
-  */
-  sendAction: function( action, target, sender, pane, context) {
-    target = this.targetForAction(action, target, sender, pane) ;
-    // HACK: If the target is a ResponderContext, forward the action.
-    if (target && target.isResponderContext) {
-      return !!target.sendAction(action, sender, context);
-    } else return target && target.tryToPerform(action, sender);
-  },
-  _responderFor: function(target, methodName) {
-    var defaultResponder = target ? target.get('defaultResponder') : null;
-    if (target) {
-      target = target.get('firstResponder') || target;
-      do {
-        if (target.respondsTo(methodName)) return target ;
-      } while (target = target.get('nextResponder')) ;
-    }
-    // HACK: Eventually we need to normalize the sendAction() method between
-    // this and the ResponderContext, but for the moment just look for a
-    // ResponderContext as the defaultResponder and return it if present.
-    if (typeof defaultResponder === SC.T_STRING) {
-      defaultResponder = SC.objectForPropertyPath(defaultResponder);
-    }
-    if (!defaultResponder) return null;
-    else if (defaultResponder.isResponderContext) return defaultResponder;
-    else if (defaultResponder.respondsTo(methodName)) return defaultResponder;
-    else return null;
-  },
-  /**
-    Attempts to determine the initial target for a given action/target/sender
-    tuple.  This is the method used by sendAction() to try to determine the
-    correct target starting point for an action before trickling up the
-    responder chain.
-    You send actions for user interface events and for menu actions.
-    This method returns an object if a starting target was found or null if no
-    object could be found that responds to the target action.
-    Passing an explicit target or pane constrains the target lookup to just
-    them; the defaultResponder and other panes are *not* searched.
-    @param {Object|String} target or null if no target is specified
-    @param {String} method name for target
-    @param {Object} sender optional sender
-    @param {SC.Pane} optional pane
-    @returns {Object} target object or null if none found
-  */
-  targetForAction: function(methodName, target, sender, pane) {
-    // 1. no action, no target...
-    if (!methodName || (SC.typeOf(methodName) !== SC.T_STRING)) {
-      return null ;
-    }
-    // 2. an explicit target was passed...
-    if (target) {
-      if (SC.typeOf(target) === SC.T_STRING) {
-        target = SC.objectForPropertyPath(target) ;
-      }
-      if (target) {
-        if (target.respondsTo && !target.respondsTo(methodName)) {
-          target = null ;
-        } else if (SC.typeOf(target[methodName]) !== SC.T_FUNCTION) {
-          target = null ;
-        }
-      }
-      return target ;
-    }
-    // 3. an explicit pane was passed...
-    if (pane) {
-      return this._responderFor(pane, methodName) ;
-    }
-    // 4. no target or pane passed... try to find target in the active panes
-    // and the defaultResponder
-    var keyPane = this.get('keyPane'), mainPane = this.get('mainPane') ;
-    // ...check key and main panes first
-    if (keyPane && (keyPane !== pane)) {
-      target = this._responderFor(keyPane, methodName) ;
-    }
-    if (!target && mainPane && (mainPane !== keyPane)) {
-      target = this._responderFor(mainPane, methodName) ;
-    }
-    // ...still no target? check the defaultResponder...
-    if (!target && (target = this.get('defaultResponder'))) {
-      if (SC.typeOf(target) === SC.T_STRING) {
-        target = SC.objectForPropertyPath(target) ;
-        if (target) this.set('defaultResponder', target) ; // cache if found
-      }
-      if (target) {
-        if (target.respondsTo && !target.respondsTo(methodName)) {
-          target = null ;
-        } else if (SC.typeOf(target[methodName]) !== SC.T_FUNCTION) {
-          target = null ;
-        }
-      }
-    }
-    return target ;
-  },
-  /**
-    Finds the view that appears to be targeted by the passed event.  This only
-    works on events with a valid target property.
-    @param {SC.Event} evt
-    @returns {SC.View} view instance or null
-  */
-  targetViewForEvent: function(evt) {
-    return evt.target ? SC.$(evt.target).view()[0] : null ;
-  },
-  /**
-    Attempts to send an event down the responder chain.  This method will
-    invoke the sendEvent() method on either the keyPane or on the pane owning
-    the target view you pass in.  It will also automatically begin and end
-    a new run loop.
-    If you want to trap additional events, you should use this method to
-    send the event down the responder chain.
-    @param {String} action
-    @param {SC.Event} evt
-    @param {Object} target
-    @returns {Object} object that handled the event or null if not handled
-  */
-  sendEvent: function(action, evt, target) {
-    var pane, ret ;
-    SC.RunLoop.begin() ;
-    // get the target pane
-    if (target) pane = target.get('pane') ;
-    else pane = this.get('keyPane') || this.get('mainPane') ;
-    // if we found a valid pane, send the event to it
-    ret = (pane) ? pane.sendEvent(action, evt, target) : null ;
-    SC.RunLoop.end() ;
-    return ret ;
-  },
-  // .......................................................
-  // EVENT LISTENER SETUP
-  //
-  /**
-    Default method to add an event listener for the named event.  If you simply
-    need to add listeners for a type of event, you can use this method as
-    shorthand.  Pass an array of event types to listen for and the element to
-    listen in.  A listener will only be added if a handler is actually installed
-    on the RootResponder of the same name.
-    @param {Array} keyNames
-    @param {Element} target
-    @returns {SC.RootResponder} receiver
-  */
-  listenFor: function(keyNames, target) {
-    keyNames.forEach( function(keyName) {
-      var method = this[keyName] ;
-      if (method) SC.Event.add(target, keyName, this, method) ;
-    },this) ;
-    target = null ;
-    return this ;
-  },
-  /**
-    Called when the document is ready to begin handling events.  Setup event
-    listeners in this method that you are interested in observing for your
-    particular platform.  Be sure to call sc_super().
-    @returns {void}
-  */
-  setup: function() {}
-});
-/*
-  Invoked when the document is ready, but before main is called.  Creates
-  an instance and sets up event listeners as needed.
-*/
-SC.ready(SC.RootResponder, SC.RootResponder.ready = function() {
-  var r;
-  r = SC.RootResponder.responder = SC.RootResponder.create() ;
-  r.setup() ;
-});