sproutcore 1.4.5-java → 1.5.0-java

data/lib/frameworks/sproutcore/frameworks/core_foundation/views/view/animation.js

@@ -0,0 +1,181 @@
+sc_require("views/view");
+sc_require("views/view/layout_style");
+
+/**
+  Properties that can be animated
+  (Hash for faster lookup)
+*/
+SC.ANIMATABLE_PROPERTIES = {
+  top:     YES,
+  left:    YES,
+  bottom:  YES,
+  right:   YES,
+  width:   YES,
+  height:  YES,
+  centerX: YES,
+  centerY: YES,
+  opacity: YES,
+  scale:   YES,
+  rotate:  YES,
+  rotateX: YES,
+  rotateY: YES,
+  rotateZ: YES
+};
+
+SC.View.reopen(
+  /** @scope SC.View.prototype */ {
+
+  didCreateLayerMixin: function() {
+    // Animation prep
+    if (SC.platform.supportsCSSTransitions) { this.resetAnimation(); }
+  },
+
+  /**
+    Animate a given property using CSS animations.
+
+    Takes a key, value and either a duration, or a hash of options.
+    The options hash has the following parameters
+      - duration: Duration of animation in seconds
+      - callback: Callback method to run when animation completes
+      - timing: Animation timing function
+
+    @param {String|Hash} key
+    @param {Object} value
+    @params {Number|Hash} duration or options
+    @returns {SC.View} receiver
+  */
+  animate: function(keyOrHash, valueOrOptions, optionsOrCallback, callback) {
+    var hash, options;
+
+    if (typeof keyOrHash === SC.T_STRING) {
+      hash = {};
+      hash[keyOrHash] = valueOrOptions;
+      options = optionsOrCallback;
+    } else {
+      hash = keyOrHash;
+      options = valueOrOptions;
+      callback = optionsOrCallback;
+    }
+
+    var optionsType = SC.typeOf(options);
+    if (optionsType === SC.T_NUMBER) {
+      options = { duration: options };
+    } else if (optionsType !== SC.T_HASH) {
+      throw "Must provide options hash or duration!";
+    }
+
+    if (callback) { options.callback = callback; }
+
+    var timing = options.timing;
+    if (timing) {
+      if (typeof timing !== SC.T_STRING) {
+        options.timing = "cubic-bezier("+timing[0]+", "+timing[1]+", "+
+                                         timing[2]+", "+timing[3]+")";
+      }
+    } else {
+      options.timing = 'linear';
+    }
+
+    var layout = SC.clone(this.get('layout')), didChange = NO, value, cur, animValue, curAnim, key;
+
+    if (!layout.animate) { layout.animate = {}; }
+
+    // Very similar to #adjust
+    for(key in hash) {
+      if (!hash.hasOwnProperty(key) || !SC.ANIMATABLE_PROPERTIES[key]) { continue; }
+      value = hash[key];
+      cur = layout[key];
+      curAnim = layout.animate[key];
+
+      // loose comparison used instead of (value === null || value === undefined)
+      if (value == null) { throw "Can only animate to an actual value!"; }
+
+      // FIXME: We should check more than duration
+      if (cur !== value || (curAnim && curAnim.duration !== options.duration)) {
+        didChange = YES;
+        layout.animate[key] = options;
+        layout[key] = value;
+      }
+    }
+
+    // now set adjusted layout
+    if (didChange) { this.set('layout', layout) ; }
+
+    return this ;
+  },
+
+  /**
+  Resets animation, stopping all existing animations.
+  */
+  resetAnimation: function() {
+    var layout = this.get('layout'),
+        animations = layout.animate,
+        didChange = NO, key;
+
+    if (!animations) { return; }
+
+    var hasAnimations;
+
+    for (key in animations) {
+      didChange = YES;
+      delete animations[key];
+    }
+
+    if (didChange) {
+      this.set('layout', layout);
+      this.notifyPropertyChange('layout');
+    }
+
+    return this;
+  },
+
+  /**
+    Called when animation ends, should not usually be called manually
+  */
+  transitionDidEnd: function(evt){
+    // WARNING: Sometimes this will get called more than once for a property. Not sure why.
+    this.get('layoutStyleCalculator').transitionDidEnd(evt);
+  },
+
+  /**
+    Setting wantsAcceleratedLayer to YES will use transforms to move the
+    layer when available. On some platforms transforms are hardware accelerated.
+  */
+  wantsAcceleratedLayer: NO,
+
+  /**
+    Specifies whether transforms can be used to move the layer.
+  */
+  hasAcceleratedLayer: function(){
+    if (this.get('wantsAcceleratedLayer') && SC.platform.supportsAcceleratedLayers) {
+      var layout = this.get('layout'),
+          animations = layout.animate,
+          AUTO = SC.LAYOUT_AUTO,
+          key;
+
+      if (animations && (animations.top || animations.left)) {
+        for (key in animations) {
+          // If we're animating other transforms at different speeds, don't use acceleratedLayer
+          if (
+            SC.CSS_TRANSFORM_MAP[key] &&
+            ((animations.top && animations.top.duration !== animations[key].duration) ||
+             (animations.left && animations.left.duration !== animations[key].duration))
+          ) {
+            return NO;
+          }
+        }
+      }
+
+      // loose comparison used instead of (layout.X === null || layout.X === undefined)
+      if (
+        layout.left != null && !SC.isPercentage(layout.left) && layout.left !== AUTO &&
+        layout.top != null && !SC.isPercentage(layout.top) && layout.top !== AUTO &&
+        layout.width != null && !SC.isPercentage(layout.width) && layout.width !== AUTO &&
+        layout.height != null && !SC.isPercentage(layout.height) && layout.height !== AUTO
+      ) {
+       return YES;
+      }
+    }
+    return NO;
+  }.property('wantsAcceleratedLayer').cacheable()
+});

data/lib/frameworks/sproutcore/frameworks/core_foundation/views/view/base.js

@@ -0,0 +1,3 @@
+
+/** @class */
+SC.CoreView = SC.Responder.extend(SC.DelegateSupport);

data/lib/frameworks/sproutcore/frameworks/core_foundation/views/view/cursor.js

@@ -0,0 +1,48 @@
+sc_require("views/view");
+
+SC.View.reopen(
+  /** @scope SC.View.prototype */ {
+
+  /**
+    You can set this to an SC.Cursor instance; whenever that SC.Cursor's
+    'cursorStyle' changes, the cursor for this view will automatically
+    be updated to match. This allows you to coordinate the cursors of
+    many views by making them all share the same cursor instance.
+
+    For example, SC.SplitView uses this ensure that it and all of its
+    children have the same cursor while dragging, so that whether you are
+    hovering over the divider or another child of the split view, the
+    proper cursor is visible.
+
+    @property {SC.Cursor String}
+  */
+  cursor: function(key, value) {
+    var parent;
+
+    if (value) { this._setCursor = value; }
+    if (this._setCursor !== undefined) { return this._setCursor; }
+
+    parent = this.get('parentView');
+    if (this.get('shouldInheritCursor') && parent) {
+      return parent.get('cursor');
+    }
+
+    return null;
+  }.property('parentView', 'shouldInheritCursor').cacheable(),
+
+  applyAttributesToContext: function(original, context) {
+    var cursor = this.get('cursor');
+    if (cursor) { context.addClass(cursor.get('className')); }
+
+    original(context);
+  }.enhance(),
+
+  /**
+    A child view without a cursor of its own inherits its parent's cursor by
+    default.  Set this to NO to prevent this behavior.
+
+    @property {Boolean}
+  */
+  shouldInheritCursor: YES
+
+});

data/lib/frameworks/sproutcore/frameworks/core_foundation/views/view/enabled.js

@@ -0,0 +1,57 @@
+sc_require("views/view");
+
+SC.View.reopen({
+  // ..........................................................
+  // IS ENABLED SUPPORT
+  //
+
+  /**
+    Set to true when the item is enabled.   Note that changing this value
+    will alter the isVisibleInWindow property for this view and any
+    child views as well as to automatically add or remove a 'disabled' CSS
+    class name.
+
+    This property is observable and bindable.
+
+    @property {Boolean}
+  */
+  isEnabled: YES,
+  isEnabledBindingDefault: SC.Binding.oneWay().bool(),
+
+  /**
+    Computed property returns YES if the view and all of its parent views
+    are enabled in the pane.  You should use this property when deciding
+    whether to respond to an incoming event or not.
+
+    This property is not observable.
+
+    @property {Boolean}
+  */
+  isEnabledInPane: function() {
+    var ret = this.get('isEnabled'), pv ;
+    if (ret && (pv = this.get('parentView'))) { ret = pv.get('isEnabledInPane'); }
+    return ret ;
+  }.property('parentView', 'isEnabled'),
+
+  /** @private
+    Observes the isEnabled property and resigns first responder if set to NO.
+    This will avoid cases where, for example, a disabled text field retains
+    its focus rings.
+
+    @observes isEnabled
+  */
+  _sc_view_isEnabledDidChange: function(){
+    if(!this.get('isEnabled') && this.get('isFirstResponder')){
+      this.resignFirstResponder();
+    }
+  }.observes('isEnabled'),
+
+  applyAttributesToContext: function(original, context) {
+    var isEnabled = this.get('isEnabled');
+
+    original(context);
+
+    context.setClass('disabled', !isEnabled);
+    context.attr('aria-disabled', !isEnabled ? 'true' : null);
+  }.enhance()
+});

data/lib/frameworks/sproutcore/frameworks/core_foundation/views/view/keyboard.js

@@ -0,0 +1,223 @@
+sc_require("views/view");
+
+SC.View.reopen({
+  // ..........................................................
+  // KEY RESPONDER
+  //
+
+  /** @property
+    YES if the view is currently first responder and the pane the view belongs
+    to is also key pane.  While this property is set, you should expect to
+    receive keyboard events.
+  */
+  isKeyResponder: NO,
+
+  /**
+    This method is invoked just before you lost the key responder status.
+    The passed view is the view that is about to gain keyResponder status.
+    This gives you a chance to do any early setup. Remember that you can
+    gain/lose key responder status either because another view in the same
+    pane is becoming first responder or because another pane is about to
+    become key.
+
+    @param {SC.Responder} responder
+  */
+  willLoseKeyResponderTo: function(responder) {},
+
+  /**
+    This method is invoked just before you become the key responder.  The
+    passed view is the view that is about to lose keyResponder status.  You
+    can use this to do any setup before the view changes.
+    Remember that you can gain/lose key responder status either because
+    another view in the same pane is becoming first responder or because
+    another pane is about to become key.
+
+    @param {SC.Responder} responder
+  */
+  willBecomeKeyResponderFrom: function(responder) {},
+
+  /**
+    Invokved just after the responder loses key responder status.
+  */
+  didLoseKeyResponderTo: function(responder) {},
+
+  /**
+    Invoked just after the responder gains key responder status.
+  */
+  didBecomeKeyResponderFrom: function(responder) {},
+
+  /**
+    This method will process a key input event, attempting to convert it to
+    an appropriate action method and sending it up the responder chain.  The
+    event is converted using the SC.KEY_BINDINGS hash, which maps key events
+    into method names.  If no key binding is found, then the key event will
+    be passed along using an insertText() method.
+
+    @param {SC.Event} event
+    @returns {Object} object that handled event, if any
+  */
+  interpretKeyEvents: function(event) {
+    var codes = event.commandCodes(), cmd = codes[0], chr = codes[1], ret;
+
+    if (!cmd && !chr) { return null ; } //nothing to do.
+
+    // if this is a command key, try to do something about it.
+    if (cmd) {
+      var methodName = SC.MODIFIED_KEY_BINDINGS[cmd] || SC.BASE_KEY_BINDINGS[cmd.match(/[^_]+$/)[0]];
+      if (methodName) {
+        var target = this, pane = this.get('pane'), handler = null;
+        while(target && !(handler = target.tryToPerform(methodName, event))){
+          target = (target===pane)? null: target.get('nextResponder') ;
+        }
+        return handler ;
+      }
+    }
+
+    if (chr && this.respondsTo('insertText')) {
+      // if we haven't returned yet and there is plain text, then do an insert
+      // of the text.  Since this is not an action, do not send it up the
+      // responder chain.
+      ret = this.insertText(chr, event);
+      return ret ? (ret===YES ? this : ret) : null ; // map YES|NO => this|nil
+    }
+
+    return null ; //nothing to do.
+  },
+
+  /**
+    This method is invoked by interpretKeyEvents() when you receive a key
+    event matching some plain text.  You can use this to actually insert the
+    text into your application, if needed.
+
+    @param {SC.Event} event
+    @returns {Object} receiver or object that handled event
+  */
+  insertText: function(chr) {
+    return NO ;
+  },
+
+  /**
+    Recursively travels down the view hierarchy looking for a view that
+    implements the key equivalent (returning to YES to indicate it handled
+    the event).  You can override this method to handle specific key
+    equivalents yourself.
+
+    The keystring is a string description of the key combination pressed.
+    The evt is the event itself. If you handle the equivalent, return YES.
+    Otherwise, you should just return sc_super.
+
+    @param {String} keystring
+    @param {SC.Event} evt
+    @returns {Boolean}
+  */
+  performKeyEquivalent: function(keystring, evt) {
+    var ret = NO,
+        childViews = this.get('childViews'),
+        len = childViews.length,
+        idx = -1, view ;
+    while (!ret && (++idx < len)) {
+      view = childViews[idx];
+
+      ret = view.tryToPerform('performKeyEquivalent', keystring, evt);
+    }
+
+    return ret ;
+  },
+
+  /**
+    Optionally points to the next key view that should gain focus when tabbing
+    through an interface.  If this is not set, then the next key view will
+    be set automatically to the next child.
+  */
+  nextKeyView: null,
+
+  /**
+    Computes the next valid key view, possibly returning the receiver or null.
+    This is the next key view that acceptsFirstResponder.
+
+    @property
+    @type SC.View
+  */
+  nextValidKeyView: function() {
+    var seen = [],
+        rootView = this.get('pane'), ret = this.get('nextKeyView');
+
+    if(!ret) { ret = rootView._computeNextValidKeyView(this, seen); }
+
+    if(SC.TABBING_ONLY_INSIDE_DOCUMENT && !ret) {
+      ret = rootView._computeNextValidKeyView(rootView, seen);
+    }
+
+    return ret ;
+  }.property('nextKeyView'),
+
+  _computeNextValidKeyView: function(currentView, seen) {
+    var ret = this.get('nextKeyView'),
+        children, i, childLen, child;
+    if(this !== currentView && seen.indexOf(currentView)!=-1 &&
+      this.get('acceptsFirstResponder') && this.get('isVisibleInWindow')){
+      return this;
+    }
+    seen.push(this); // avoid cycles
+
+    // find next sibling
+    if (!ret) {
+      children = this.get('childViews');
+      for(i=0, childLen = children.length; i<childLen; i++){
+        child = children[i];
+        if(child._computeNextValidKeyView && child.get('isVisibleInWindow') && child.get('isVisible')){
+          ret = child._computeNextValidKeyView(currentView, seen);
+        }
+        if (ret) { return ret; }
+      }
+      ret = null;
+    }
+    return ret ;
+  },
+
+  /**
+    Optionally points to the previous key view that should gain focus when
+    tabbing through the interface. If this is not set then the previous
+    key view will be set automatically to the previous child.
+  */
+  previousKeyView: null,
+
+  /**
+    Computes the previous valid key view, possibly returning the receiver or
+    null.  This is the previous key view that acceptsFirstResponder.
+
+    @property
+    @type SC.View
+  */
+  previousValidKeyView: function() {
+    var seen = [],
+        rootView = this.pane(), ret = this.get('previousKeyView');
+    if(!ret) { ret = rootView._computePreviousValidKeyView(this, seen); }
+    return ret ;
+  }.property('previousKeyView'),
+
+  _computePreviousValidKeyView: function(currentView, seen) {
+    var ret = this.get('previousKeyView'),
+        children, i, child;
+
+    if(this !== currentView && seen.indexOf(currentView)!=-1 &&
+      this.get('acceptsFirstResponder') && this.get('isVisibleInWindow')){
+      return this;
+    }
+    seen.push(this); // avoid cycles
+
+    // find next sibling
+    if (!ret) {
+      children = this.get('childViews');
+      for(i=children.length-1; 0<=i; i--){
+        child = children[i];
+        if(child._computePreviousValidKeyView && child.get('isVisibleInWindow') && child.get('isVisible')){
+          ret = child._computePreviousValidKeyView(currentView, seen);
+        }
+        if (ret) { return ret; }
+      }
+      ret = null;
+    }
+    return ret ;
+  }
+});