spade 0.0.1

data/sproutcore/frameworks/core_foundation/mixins/selection_support.js

@@ -0,0 +1,250 @@
+// ==========================================================================
+// 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)
+// ==========================================================================
+/**
+  @namespace
+
+  Implements common selection management properties for controllers.
+
+  Selection can be managed by any controller in your applications.  This
+  mixin provides some common management features you might want such as
+  disabling selection, or restricting empty or multiple selections.
+
+  To use this mixin, simply add it to any controller you want to manage
+  selection and call updateSelectionAfterContentChange()
+  whenever your source content changes.  You can also override the properties
+  defined below to configure how the selection management will treat your
+  content.
+
+  This mixin assumes the arrangedObjects property will return an SC.Array of
+  content you want the selection to reflect.
+
+  Add this mixin to any controller you want to manage selection.  It is
+  already applied to the CollectionController and ArrayController.
+
+  @since SproutCore 1.0
+*/
+SC.SelectionSupport = {
+
+  // ..........................................................
+  // PROPERTIES
+  //
+  /**
+    Walk like a duck.
+
+    @property {Boolean}
+  */
+  hasSelectionSupport: YES,
+
+  /**
+    If YES, selection is allowed. Default is YES.
+
+    @property {Boolean}
+  */
+  allowsSelection: YES,
+
+  /**
+    If YES, multiple selection is allowed. Default is YES.
+
+    @property {Boolean}
+  */
+  allowsMultipleSelection: YES,
+
+  /**
+    If YES, allow empty selection Default is YES.
+
+    @property {Boolean}
+  */
+  allowsEmptySelection: YES,
+
+  /**
+    Override to return the first selectable object.  For example, if you
+    have groups or want to otherwise limit the kinds of objects that can be
+    selected.
+
+    the default imeplementation returns firstObject property.
+
+    @returns {Object} first selectable object
+  */
+  firstSelectableObject: function() {
+    return this.get('firstObject');
+  }.property(),
+
+  /**
+    This is the current selection.  You can make this selection and another
+    controller's selection work in concert by binding them together. You
+    generally have a master selection that relays changes TO all the others.
+
+    @property {SC.SelectionSet}
+  */
+  selection: function(key, value) {
+
+    var old = this._scsel_selection,
+    oldlen = old ? old.get('length') : 0,
+    content,
+    empty,
+    len;
+
+    // whenever we have to recompute selection, reapply all the conditions to
+    // the selection.  This ensures that changing the conditions immediately
+    // updates the selection.
+    //
+    // Note also if we don't allowSelection, we don't clear the old selection;
+    // we just don't allow it to be changed.
+    if ((value === undefined) || !this.get('allowsSelection')) { value = old; }
+
+    len = (value && value.isEnumerable) ? value.get('length') : 0;
+
+    // if we don't allow multiple selection
+    if ((len > 1) && !this.get('allowsMultipleSelection')) {
+
+      if (oldlen > 1) {
+        value = SC.SelectionSet.create().addObject(old.get('firstObject')).freeze();
+        len = 1;
+      } else {
+        value = old;
+        len = oldlen;
+      }
+    }
+
+    // if we don't allow empty selection, block that also.  select first
+    // selectable item if necessary.
+    if ((len === 0) && !this.get('allowsEmptySelection')) {
+      if (oldlen === 0) {
+        value = this.get('firstSelectableObject');
+        if (value) { value = SC.SelectionSet.create().addObject(value).freeze(); }
+        else { value = SC.SelectionSet.EMPTY; }
+        len = value.get('length');
+
+      } else {
+        value = old;
+        len = oldlen;
+      }
+    }
+
+    // if value is empty or is not enumerable, then use empty set
+    if (len === 0) { value = SC.SelectionSet.EMPTY; }
+
+    // always use a frozen copy...
+    value = value.frozenCopy();
+    this._scsel_selection = value;
+
+    return value;
+
+  }.property('arrangedObjects', 'allowsEmptySelection', 'allowsMultipleSelection', 'allowsSelection').cacheable(),
+
+  /**
+    YES if the receiver currently has a non-zero selection.
+
+    @property {Boolean}
+  */
+  hasSelection: function() {
+    var sel = this.get('selection');
+    return !! sel && (sel.get('length') > 0);
+  }.property('selection').cacheable(),
+
+  // ..........................................................
+  // METHODS
+  //
+  /**
+    Selects the passed objects in your content.  If you set "extend" to YES,
+    then this will attempt to extend your selection as well.
+
+    @param {SC.Enumerable} objects objects to select
+    @param {Boolean} extend optionally set to YES to extend selection
+    @returns {Object} receiver
+  */
+  selectObjects: function(objects, extend) {
+
+    // handle passing an empty array
+    if (!objects || objects.get('length') === 0) {
+      if (!extend) { this.set('selection', SC.SelectionSet.EMPTY); }
+      return this;
+    }
+
+    var sel = this.get('selection');
+    if (extend && sel) { sel = sel.copy(); }
+    else { sel = SC.SelectionSet.create(); }
+
+    sel.addObjects(objects).freeze();
+    this.set('selection', sel);
+    return this;
+  },
+
+  /**
+    Selects a single passed object in your content.  If you set "extend" to
+    YES then this will attempt to extend your selection as well.
+
+    @param {Object} object object to select
+    @param {Boolean} extend optionally set to YES to extend selection
+    @returns {Object} receiver
+  */
+  selectObject: function(object, extend) {
+    if (object === null) {
+      if (!extend) { this.set('selection', null); }
+      return this;
+
+    } else { return this.selectObjects([object], extend); }
+  },
+
+  /**
+    Deselects the passed objects in your content.
+
+    @param {SC.Enumerable} objects objects to select
+    @returns {Object} receiver
+  */
+  deselectObjects: function(objects) {
+
+    if (!objects || objects.get('length') === 0) { return this; } // nothing to do
+    var sel = this.get('selection');
+    if (!sel || sel.get('length') === 0) { return this; } // nothing to do
+    // find index for each and remove it
+    sel = sel.copy().removeObjects(objects).freeze();
+    this.set('selection', sel.freeze());
+    return this;
+  },
+
+  /**
+    Deselects the passed object in your content.
+
+    @param {SC.Object} object single object to select
+    @returns {Object} receiver
+  */
+  deselectObject: function(object) {
+    if (!object) { return this; } // nothing to do
+    else { return this.deselectObjects([object]); }
+  },
+
+  /**
+    Call this method whenever your source content changes to ensure the
+    selection always remains up-to-date and valid.
+
+    @returns {Object}
+  */
+  updateSelectionAfterContentChange: function() {
+    var arrangedObjects = this.get('arrangedObjects');
+    var selectionSet = this.get('selection');
+    var allowsEmptySelection = this.get('allowsEmptySelection');
+    var indexSet; // Selection index set for arranged objects
+
+    // If we don't have any selection, there's nothing to update
+    if (!selectionSet) { return this; }
+    // Remove any selection set objects that are no longer in the content
+    indexSet = selectionSet.indexSetForSource(arrangedObjects);
+    if ((indexSet && (indexSet.get('length') !== selectionSet.get('length'))) || (!indexSet && (selectionSet.get('length') > 0))) { // then the selection content has changed
+      selectionSet = selectionSet.copy().constrain(arrangedObjects).freeze();
+      this.set('selection', selectionSet);
+    }
+
+    // Reselect an object if required (if content length > 0)
+    if ((selectionSet.get('length') === 0) && arrangedObjects && (arrangedObjects.get('length') > 0) && !allowsEmptySelection) {
+      this.selectObject(this.get('firstSelectableObject'), NO);
+    }
+
+    return this;
+  }
+
+};

data/sproutcore/frameworks/core_foundation/mixins/string.js

@@ -0,0 +1,163 @@
+// ==========================================================================
+// 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)
+// ==========================================================================
+
+sc_require('system/locale');
+
+// These are basic enhancements to the string class used throughout
+// SproutCore.
+/** @private */
+SC.STRING_TITLEIZE_REGEXP = (/([\s|\-|\_|\n])([^\s|\-|\_|\n]?)/g);
+SC.STRING_DECAMELIZE_REGEXP = (/([a-z])([A-Z])/g);
+SC.STRING_DASHERIZE_REGEXP = (/[ _]/g);
+SC.STRING_DASHERIZE_CACHE = {};
+
+/**
+  @namespace
+
+  SproutCore implements a variety of enhancements to the built-in String
+  object that make it easy to perform common substitutions and conversions.
+
+  Most of the utility methods defined here mirror those found in Prototype
+  1.6.
+
+  @since SproutCore 1.0
+*/
+SC.String = {
+  /**
+    Capitalizes a string.
+
+    h2. Examples
+
+    | *Input String* | *Output String* |
+    | my favorite items | My favorite items |
+    | css-class-name | Css-class-name |
+    | action_name | Action_name |
+    | innerHTML | InnerHTML |
+
+    @return {String} capitalized string
+  */
+  capitalize: function() {
+    return this.charAt(0).toUpperCase() + this.slice(1) ;
+  },
+
+  /**
+    Camelizes a string.  This will take any words separated by spaces, dashes
+    or underscores and convert them into camelCase.
+
+    h2. Examples
+
+    | *Input String* | *Output String* |
+    | my favorite items | myFavoriteItems |
+    | css-class-name | cssClassName |
+    | action_name | actionName |
+    | innerHTML | innerHTML |
+
+    @returns {String} camelized string
+  */
+  camelize: function() {
+    var ret = this.replace(SC.STRING_TITLEIZE_REGEXP,
+      function(str,separater,character) {
+        return (character) ? character.toUpperCase() : '' ;
+      }) ;
+    var first = ret.charAt(0), lower = first.toLowerCase() ;
+    return (first !== lower) ? (lower + ret.slice(1)) : ret ;
+  },
+
+  /**
+    Converts a camelized string into all lower case separated by underscores.
+
+    h2. Examples
+
+    | *Input String* | *Output String* |
+    | my favorite items | my favorite items |
+    | css-class-name | css-class-name |
+    | action_name | action_name |
+    | innerHTML | inner_html |
+
+    @returns {String} the decamelized string.
+  */
+  decamelize: function() {
+    return this.replace(SC.STRING_DECAMELIZE_REGEXP,'$1_$2').toLowerCase();
+  },
+
+  /**
+    Converts a camelized string or a string with spaces or underscores into
+    a string with components separated by dashes.
+
+    h2. Examples
+
+    | *Input String* | *Output String* |
+    | my favorite items | my-favorite-items |
+    | css-class-name | css-class-name |
+    | action_name | action-name |
+    | innerHTML | inner-html |
+
+    @returns {String} the dasherized string.
+  */
+  dasherize: function() {
+    // Do we have the item in our cache?
+    var cache = SC.STRING_DASHERIZE_CACHE,
+        ret   = cache[this];
+
+    if (ret) {
+      return ret;
+    }
+    else {
+      ret = this.decamelize().replace(SC.STRING_DASHERIZE_REGEXP,'-') ;
+
+      // Add the item to our cache.
+      cache[this] = ret;
+    }
+
+    return ret;
+  },
+
+  /**
+    Localizes the string.  This will look up the reciever string as a key
+    in the current Strings hash.  If the key matches, the loc'd value will be
+    used.  The resulting string will also be passed through fmt() to insert
+    any variables.
+
+    @param args {Object...} optional arguments to interpolate also
+    @returns {String} the localized and formatted string.
+  */
+  loc: function() {
+    // NB: This could be implemented as a wrapper to locWithDefault() but
+    // it would add some overhead to deal with the arguments and adds stack
+    // frames, so we are keeping the implementation separate.
+    if(!SC.Locale.currentLocale) SC.Locale.createCurrentLocale();
+    var str = SC.Locale.currentLocale.locWithDefault(this);
+    if (SC.typeOf(str) !== SC.T_STRING) str = this;
+    return str.fmt.apply(str,arguments) ;
+  },
+
+  /**
+    Works just like loc() except that it will return the passed default
+    string if a matching key is not found.
+
+    @param {String} def the default to return
+    @param {Object...} args optional formatting arguments
+    @returns {String} localized and formatted string
+  */
+  locWithDefault: function(def) {
+    if(!SC.Locale.currentLocale) SC.Locale.createCurrentLocale();
+    var str = SC.Locale.currentLocale.locWithDefault(this, def);
+    if (SC.typeOf(str) !== SC.T_STRING) str = this;
+    var args = SC.$A(arguments); args.shift(); // remove def param
+    return str.fmt.apply(str,args) ;
+  }
+};
+
+// Apply SC.String mixin to built-in String object
+SC.supplement(String.prototype, SC.String) ;
+
+/** @private */
+String.prototype.loc = SC.String.loc; // Two places define it, and we want the version at SC.String.loc
+
+/** @private */
+SC.String.fmt = String.prototype.fmt; // copy from runtime
+

data/sproutcore/frameworks/core_foundation/panes/keyboard.js

@@ -0,0 +1,68 @@
+sc_require("panes/pane");
+
+SC.Pane.reopen(
+  /** @scope SC.Pane.prototype */ {
+
+  performKeyEquivalent: function(keystring, evt) {
+    var ret = sc_super() ; // try normal view behavior first
+    if (!ret) {
+      var defaultResponder = this.get('defaultResponder') ;
+      if (defaultResponder) {
+        // try default responder's own performKeyEquivalent method,
+        // if it has one...
+        if (defaultResponder.performKeyEquivalent) {
+          ret = defaultResponder.performKeyEquivalent(keystring, evt) ;
+        }
+
+        // even if it does have one, if it doesn't handle the event, give
+        // methodName-style key equivalent handling a try
+        if (!ret && defaultResponder.tryToPerform) {
+          ret = defaultResponder.tryToPerform(keystring, evt) ;
+        }
+      }
+    }
+    return ret ;
+  },
+
+  /** @private
+    If the user presses the tab key and the pane does not have a first
+    responder, try to give it to the next eligible responder.
+
+    If the keyDown event reaches the pane, we can assume that no responders in
+    the responder chain, nor the default responder, handled the event.
+  */
+  keyDown: function(evt) {
+    var nextValidKeyView;
+
+    // Handle tab key presses if we don't have a first responder already
+    if ((evt.which === 9 || (SC.browser.mozilla && evt.keyCode ===9)) && !this.get('firstResponder')) {
+      // Cycle forwards by default, backwards if the shift key is held
+      if (evt.shiftKey) {
+        nextValidKeyView = this.get('previousValidKeyView');
+      } else {
+        nextValidKeyView = this.get('nextValidKeyView');
+      }
+
+      if (nextValidKeyView) {
+        this.makeFirstResponder(nextValidKeyView);
+        return YES;
+      }
+    }
+
+    return NO;
+  },
+
+  /** @private method forwards status changes in a generic way. */
+  _forwardKeyChange: function(shouldForward, methodName, pane, isKey) {
+    var keyView, responder, newKeyView;
+    if (shouldForward && (responder = this.get('firstResponder'))) {
+      newKeyView = (pane) ? pane.get('firstResponder') : null ;
+      keyView = this.get('firstResponder') ;
+      if (keyView && keyView[methodName]) { keyView[methodName](newKeyView); }
+
+      if ((isKey !== undefined) && responder) {
+        responder.set('isKeyResponder', isKey);
+      }
+    }
+  }
+});