sproutcore 0.9.4 → 0.9.5

data/frameworks/sproutcore/foundation/string.js

@@ -124,23 +124,57 @@ String.prototype.fmt = String.prototype.format ;
 // Add strings for various languages to this collection.  String.loc()
 // method will try to localize the string passed using the current language.
 // if the language is not available, it will use English.
-Object.extend(String,{
+Object.extend(String,
+/** @scope String @static */ {
+
+  /**
+    The current browser language as a two letter code.
+  */
+  browserLanguage: ((navigator.language || navigator.browserLanguage).split('-', 1)[0]),
+  
+  /**
+    If YES, localization will favor the detected language instead of the
+    preferred one.
+  */
+  useAutodetectedLanguage: NO,
+  
+  /**
+    This property is set by the build tools to the current build language.
+  */
+  preferredLanguage: null,
   
-  // Default language is English. Currently French, German, and Japanese are
-  // detected. All other languages default to English.
+  /**
+    Returns the hash key to use for loc strings.  The default implementation
+    will autodetect the browser language and look for a loc string to 
+    match.  If it can't find one then it will introspect to find loc strings
+    that are defined and use those instead.
+  */
   currentLanguage: function () {
-    var browserLanguage = (navigator.language || navigator.browserLanguage).split('-', 1);
-    switch(browserLanguage[0])
+    
+    var ret = (this.useAutodetectedLanguage) ? (this.browserLanguage || this.preferredLanguage || 'en') : (this.preferredLanguage || this.browserLanguage || 'en') ;
+
+    // then try a couple of normalized forms...
+    if (!this[ret]) switch(ret)
     {
       case 'fr':
-        return 'French';
+        ret = 'French'; 
+        break ;
       case 'de':
-        return 'German';
+        ret = 'German'; 
+        break ;
       case 'ja':
-        return 'Japanese';
+      case 'jp':
+        ret = 'Japanese'; 
+        break ;
+      case 'en':
+        ret = 'English' ;
+        break ;
+      
       default:
-        return 'English'; 
+        break ;
     }
+    
+    return ret ;
   }
 
 });

data/frameworks/sproutcore/globals/window.js

@@ -7,6 +7,8 @@ require('Core') ;
 require('foundation/responder');
 require('panes/pane');
 
+SC.CAPTURE_BACKSPACE_KEY = NO ;
+
 // The window global object is automatically setup for each window that you 
 // load.  Window listens for mouse and keyboard events and routes them to the
 // first responder.  Using the firstResponder method you can control who gets
@@ -112,19 +114,36 @@ SC.window = SC.PaneView.extend({
   // we can map to some non-printable set of keycodes.)
   _onkeydown: function(evt)
   {
+    // Firefox does NOT handle delete here...
+    if (SC.Platform.Firefox > 0 && (evt.which === 8)) {
+      return true ;
+    }
+    
     // modifier keys are handled separately by the 'flagsChanged' event
     this._handleModifierChanges(evt);
-    if (this._isModifierKey(evt)) return;
-    if (!this._isFunctionOrNonPrintableKey(evt)) return true;  // let normal browser processing do its thing.
-    return this._sendEvent('keyDown', evt);
+    if (this._isModifierKey(evt)) return false;
+    
+    // let normal browser processing do its thing.
+    if (!this._isFunctionOrNonPrintableKey(evt)) return true;  
+    var ret = this._sendEvent('keyDown', evt);
+    return ret ;
   },
 
   // this one gets used for all the other keys not handled by key down.
+  // FireFox also needs to handle delete here...
   _onkeypress: function(evt)
   {
-    if (this._isFunctionOrNonPrintableKey(evt)) return; // handled in _onkeydown
-    if (evt.charCode != undefined && evt.charCode == 0) return;
-    return this._sendEvent('keyDown', evt);
+
+    // handled in _onkeydown
+    if (SC.Platform.Firefox > 0 && (evt.which === 8)) {
+      var ret = this._sendEvent('keyDown', evt);
+
+    } else {
+      if (this._isFunctionOrNonPrintableKey(evt)) return true; 
+      if (evt.charCode != undefined && evt.charCode == 0) return true;
+      var ret = this._sendEvent('keyDown', evt);
+    }
+    return ret ;
   },
   
   _onkeyup: function(evt)
@@ -342,10 +361,16 @@ SC.window = SC.PaneView.extend({
     var win = this ;
     win._EVTS.each(function(e) {
       var func = win['_on' + e] ;
-      var target = (SC.isIE() && (e != 'resize')) ? document : window ;
+      var target = (e != 'resize') ? document : window ;
       if (func) {
         var f = func.bindAsEventListener(win) ;
-        Event.observe(target, e, f) ;
+
+        if (e === 'keypress' && SC.CAPTURE_BACKSPACE_KEY && SC.Platform.Firefox > 0) {
+          document.onkeypress = f ;
+        } else {
+          Event.observe(target, e, f) ;
+        }
+
         win._listenerCache.push([target, e, f]) ;
       }
     });
@@ -353,10 +378,10 @@ SC.window = SC.PaneView.extend({
     this.get('size') ; // fetch the size from the window and save it.
     this.set('isVisibleInWindow', true) ;
     this._onfocus() ;
+    
   }
 }).viewFor($tag('body')) ;
 
-
 // events:
 // window.onfocus --
 //  notify all views that they now have window focus.

data/frameworks/sproutcore/lib/button_views.rb

@@ -262,6 +262,7 @@ view_helper :radio_group_view do
   # get the layout mode.
   var :layout, :vertical
   css_class_names << 'sc-radio-group-view'
+  css_class_names << 'radio'
   css_class_names << @layout if @layout
   
   var :tag, 'span'

data/frameworks/sproutcore/lib/collection_view.rb

@@ -29,6 +29,7 @@ view_helper :collection_view do
   property :content_value_editable, :key => 'contentValueIsEditable'
   property :accepts_first_responder, true
   property :can_reorder_content
+  property :can_delete_content
   
   property :content_icon_key
   

data/frameworks/sproutcore/lib/core_views.rb

@@ -49,6 +49,9 @@ view_helper :view do
   property :can_collapse
   property :collapsed, :key => 'isCollapsed'
   
+  # General delegate support
+  property(:delegate) { |x| x }
+  property :drop_target, :key => 'isDropTarget'
 
   # set panel type
   var :panel

data/frameworks/sproutcore/lib/index.rhtml

@@ -24,7 +24,7 @@
     <%= stylesheets_for_client %>
 <%= @content_for_page_styles %>
   </head>
-  <body class="<%= @theme || 'sc-theme' %>">    
+  <body class="<%= @theme || 'sc-theme' %> focus">    
 <% #
    # This is where you root body element will appear.  To cause your 
    # content to appear here, just declare content_for('body') in one of

data/frameworks/sproutcore/mixins/collection_view_delegate.js

@@ -0,0 +1,201 @@
+// ========================================================================
+// SproutCore
+// copyright 2006-2008 Sprout Systems, Inc.
+// ========================================================================
+
+/**
+  Indicates that the collection view expects to accept a drop ON the specified
+  item.
+*/
+SC.DROP_ON = 0x01;
+
+/**
+  Indicates that the collection view expects to accept a drop BEFORE the 
+  specified item.
+*/
+SC.DROP_BEFORE = 0x02;
+
+/**
+  Indicates that the collection view want's to know which operations would 
+  be allowed for either drop operation.
+*/
+SC.DROP_ANY = 0x03;
+
+/**
+  @namespace
+
+  A Collection View Delegate is consulted by a SC.CollectionView's to control
+  certain behaviors such as selection control and drag and drop behaviors.
+  
+  To act as a Collection Delegate, the object should be set as the delegate
+  property of the collection view and should implement one or more of the
+  methods below.
+  
+  You can also choose to mixin this delegate to get suitable default 
+  implementations of these methods.
+  
+  @since SproutCore 1.0
+*/
+SC.CollectionViewDelegate = {
+  
+  /**
+    This method will be called anytime the collection view is about to
+    change the selection in response to user mouse clicks or keyboard events.
+    
+    You can use this method to adjust the proposed selection, eliminating any
+    selected objects that cannot be selected.  The default implementation of
+    this method simply returns the proposed selection.
+    
+    @param view {SC.CollectionView} the collection view
+    @param sel {Array} Proposed array of selected objects.
+    @returns The actual array allowed or null if no change is allowed.
+  */
+  collectionViewSelectionForProposedSelection: function(view, sel) {
+    return sel ;
+  },
+
+  /**
+    Called by the collection view just before it starts a drag to give you
+    an opportunity to decide if the drag should be allowed. 
+    
+    You can use this method to implement fine-grained control over when a 
+    drag will be allowed and when it will not be allowed.  For example, you
+    may enable content reordering but then implement this method to prevent
+    reordering of certain items in the view.
+    
+    The default implementation always returns YES.
+    
+    @param view {SC.CollectionView} the collection view
+    @returns {Boolean} YES to alow, NO to prevent it
+  */
+  collectionViewShouldBeginDrag: function(view) { return YES; },
+  
+  /**
+    Called by the collection view just before it starts a drag so that 
+    you can provide the data types you would like to support in the data.
+    
+    You can implement this method to return an array of the data types you
+    will provide for the drag data.
+    
+    If you return null or an empty array, can you have set canReorderContent
+    to YES on the CollectionView, then the drag will go ahead but only 
+    reordering will be allowed.  If canReorderContent is NO, then the drag
+    will not be allowed to start.
+    
+    If you simply want to control whether a drag is allowed or not, you
+    should instead implement collectionViewShouldBeginDrag().
+    
+    The default returns an empty array.
+    
+    @param view {SC.CollectionView} the collection view to begin dragging.
+    @returns {Array} array of supported data types.
+  */
+  collectionViewDragDataTypes: function(view) { return []; },
+  
+  /**
+    Called by a collection view when a drag concludes to give you the option
+    to provide the drag data for the drop.
+    
+    This method should be implemented essentially as you would implement the
+    dragDataForType() if you were a drag data source.  You will never be asked
+    to provide drag data for a reorder event, only for other types of data.
+    
+    The default implementation returns null.
+    
+    @param view {SC.CollectionView} the collection view that initiated the drag
+    @param dataType {String} the data type to provide
+    @param drag {SC.Drag} the drag object
+    @returns {Object} the data object or null if the data could not be provided.
+  */
+  collectionViewDragDataForType: function(view, dataType, drag) {  
+    return null ;
+  },
+  
+  /**
+    Called by the collection view during a drag to let you determine the
+    kind and location of a drop you might want to accept.
+    
+    You can override this method to implement fine-grained control over how
+    and when a dragged item is allowed to be dropped into a collection view.
+
+    This method will be called by the collection view both to determine in 
+    general which operations you might support and specifically the operations
+    you would support if the user dropped an item over a specific location.
+    
+    If the dropOperations parameter is SC.DROP_ANY, then you should simply
+    return the logical-or of all the operations you might possibly support
+    (or you can simply return the value of proposedDragOperation if you
+    support anything.)  In this case, you should make your method as fast as
+    possible since it may be called frequently during a drag.
+    
+    If hte dropOperation parameter is SC.DROP_ON or SC.DROP_BEFORE, then the
+    proposedInsertionPoint will be a non-negative value and you should
+    determine the specific operations you will support if the user dropped the
+    drag item at that point.
+    
+    If you do not like the proposed drop operation or insertion point, you 
+    can override these properties as well by setting the proposedDropOperation
+    and proposedInsertionIndex properties on the collection view during this
+    method.  These properties are ignored all other times.
+    
+    @param view {SC.CollectionView} the collection view
+    @param drag {SC.Drag} the current drag object
+    @param dropOperation {String} the proposed drop operation.  Will be one of SC.DROP_ON, SC.DROP_BEFORE, or SC.DROP_ANY.
+    @param proposedInsertionIndex {Number} an index into the content array 
+      representing the proposed insertion point.
+    @param proposedDragOperations {Number} proposed logical OR of allowed drag operations.
+    @returns the allowed drag operation.  Defaults to proposedDragOperation
+  */
+  collectionViewValidateDrop: function(view, drag, dropOperation, proposedInsertionIndex, proposedDragOperation) {
+    return proposedDragOperation ;
+  },
+  
+  /**
+    Called by the collection view to actually accept a drop.  This method will
+    only be invoked AFTER your validateDrop method has been called to
+    determine if you want to even allow the drag operation to go through.
+    
+    You should actually make changes to the data model if needed here and
+    then return the actual drag operation that was performed.  If you return
+    SC.DRAG_NONE and the dragOperation was SC.DRAG_REORDER, then the default
+    reorder behavior will be provided by the collection view.
+    
+    @param  view {SC.CollectionView}
+  */
+  collectionViewAcceptDrop: function(view, drag, dropOperation, proposedInsertionIndex, dragOperation) {
+    return SC.DRAG_NONE ;
+  },
+  
+  /**
+    Called by the collection view whenever the deleteSelection() method is
+    called.  You can implement this method to get fine-grained control over
+    which items can be deleted.  To prevent deletion, return null.
+    
+    This method is only called if canDeleteContent is YES on the collection
+    view.
+    
+    @param view {SC.CollectionView} the collection view
+    @param item {Array} proposed array  of items to delete.
+    @returns {Array} items allowed to delete or null.
+  */
+  collectionViewShouldDeleteContent: function(view, items) { return items; },
+  
+  /**
+    Called by the collection view to actually delete the selected items.
+    
+    The default behavior will use standard array operators to remove the 
+    items from the content array.  You can implement this method to provide
+    your own deletion method.
+    
+    If you simply want to controls the items to be deleted, you should instead
+    implement collectionViewShouldDeleteItems().  This method will only be 
+    called if canDeleteContent is YES and collectionViewShouldDeleteContent()
+    returns a non-empty array.
+    
+    @param view {SC.CollectionView} the view collection view
+    @param items {Array} the items to delete
+    @returns {Boolean} YES if the operation succeeded, NO otherwise.
+  */
+  collectionViewDeleteContent: function(view, items) { return NO; }
+
+};

data/frameworks/sproutcore/mixins/observable.js

@@ -768,13 +768,8 @@ SC.NotificationQueue = {
     var now = start ;
     var n = null ;
     while(((now - start) < this.maxFlush) && (n = this.queue.pop())) { 
-      try {
-        var t = n[0] || n[1] ;
-        n[1].apply(t,n[2]) ;
-      }
-      catch(e) {
-        console.log("Exception while notify("+n[2]+"): " + e) ;
-      } // catch  
+      var t = n[0] || n[1] ;
+      n[1].apply(t,n[2]) ;
       now = Date.now() ;
     }
     this._flushing = false ;

data/frameworks/sproutcore/models/record.js

@@ -164,7 +164,7 @@ SC.Record = SC.Object.extend({
   // This will return the current set of attributes as a hash you can send back
   // to the server.
   attributes: function() {
-    return $H(this._attributes) ;
+    return Object.clone(this._attributes) ;
   }.property(),
   
   // If you try to get/set a property not defined by the record, then this method

data/frameworks/sproutcore/models/store.js

@@ -5,21 +5,46 @@
 
 require('foundation/object') ;
 
-// The Store is where you can find all of your records.  You should also
-// use this to define your various types of records, since this will be
-// used to automatically update from data coming from the server.
-//
-// You should create a store for each application.  This allows the records
-// for apps to be kept separate, even if they live in the same page.
-//
-SC.Store = SC.Object.create({
+/**
+  @class
+
+  The Store is where you can find all of your records.  You should also
+  use this to define your various types of records, since this will be
+  used to automatically update from data coming from the server.
+
+  You should create a store for each application.  This allows the records
+  for apps to be kept separate, even if they live in the same page.
+
+  @extends SC.Object
+  @static
+  @since SproutCore 1.0
+*/
+SC.Store = SC.Object.create(
+/** @scope SC.Store.prototype */ {
+  
+  /**
+    Pushes updated data to all the named records.  
+  
+    This method is often called from a server to update the store with the 
+    included record objects.
   
-  // This can be passed in from a Server to push updated data to all the 
-  // named records.  The parameter should be an array of hashes.  Each hash
-  // can contain arrays or strings. Each one should also have a recordType
-  // property, which points to the record type.  dataSource is the server.
-  // this will be automatically set on all the objects so that their future
-  // refreshes will come from the server.
+    You can use this method yourself to mass update the store whenever you 
+    retrieve new records from the server.  The first parameter should contain
+    an array of JSON-compatible hashes.  The hashes can have any properties 
+    you want but they should at least contain the following two keys:
+  
+    - guid: This is a unique identifier for the record. 
+    - type: The name of the record type.  I.e. "Contact" or "Photo"
+  
+    @param dataHashes {Array} array of hash records.  See discussion.
+    @param dataSource {Object} the data source.  Usually a server object.
+    @param recordType {SC.Record} optional record type, used if type is not 
+      found in the data hashes itself.
+    @param isLoaded {Boolean} YES if the data hashes represent the full set of 
+      data loaded from the server.  NO otherwise.
+
+    @returns {Array} Array of records that were actually created/updated.
+  */
   updateRecords: function(dataHashes, dataSource, recordType, isLoaded) {
     
     this.set('updateRecordsInProgress',true) ;
@@ -71,8 +96,10 @@ SC.Store = SC.Object.create({
   // Record Helpers
   //
   
-  // add a record instance to the store.  The record will now be monitored for
-  // changes.
+  /**
+    Add a record instance to the store.  The record will now be monitored for
+    changes.
+  */
   addRecord: function(rec) {
     // save record in a cache
     rec.needsAddToStore = false;
@@ -95,8 +122,10 @@ SC.Store = SC.Object.create({
     this.recordDidChange(rec) ;
   },
 
-  // remove a record instance from the store.  The record will no longer be
-  // monitored for changes and may be deleted.
+  /**
+    remove a record instance from the store.  The record will no longer be
+    monitored for changes and may be deleted.
+  */  
   removeRecord: function(rec) {
     // remove from cache
     var guid = rec._storeKey();
@@ -119,11 +148,13 @@ SC.Store = SC.Object.create({
   },
 
   /**
-  * Since records are cached by primaryKey, whenever that key changes we need to re-cache it in the proper place
-  * @param {string} oldkey Previous primary key
-  * @param {string} newkey New primary key
-  * @param {SC.Record} rec The object to relocate
-  * @return {SC.Record} The record passed in
+    Since records are cached by primaryKey, whenever that key changes we need 
+    to re-cache it in the proper place
+    
+    @param {string} oldkey Previous primary key
+    @param {string} newkey New primary key
+    @param {SC.Record} rec The object to relocate
+    @returns {SC.Record} The record passed in
   **/
   relocateRecord: function( oldkey, newkey, rec )
   {
@@ -141,8 +172,10 @@ SC.Store = SC.Object.create({
   },
 
 
-  // You can pass any number of condition hashes to this, ending with a
-  // recordType.  It will AND the results of each condition hash.
+  /**
+    You can pass any number of condition hashes to this, ending with a
+    recordType.  It will AND the results of each condition hash.
+  */  
   findRecords: function() {
     var allConditions = $A(arguments) ;
     var recordType = allConditions.pop() ;
@@ -174,8 +207,10 @@ SC.Store = SC.Object.create({
     return ret ;
   },
   
-  // finds the record with the primary key value.  If the record does not 
-  // exist, creates it.
+  /**
+    finds the record with the primary key value.  If the record does not 
+    exist, creates it.
+  */
   getRecordFor: function(pkValue,recordType,dontAutoaddRecord) {
     var ret = this._getRecordFor(pkValue,recordType) ;
     if (!ret) {
@@ -188,6 +223,22 @@ SC.Store = SC.Object.create({
     return ret ;
   },
   
+  /**
+    Returns an array of all records in the store.  Mostly used for storing.
+  */
+  records: function() {
+    var ret = [] ;
+    if (this._quickCache) {
+      for(var key in this._quickCache) {
+        var recs = this._quickCache[key] ;
+        for(var recKey in recs) {
+          ret.push(recs[recKey]) ;
+        }
+      }
+    }
+    return ret ;
+  }.property(),
+  
   // ....................................
   // Collection Helpers
   //
@@ -231,7 +282,9 @@ SC.Store = SC.Object.create({
   //
   _records: {}, _changedRecords: null, _collections: {},
   
-  // called whenever properties on a record change.
+  /** @private
+    called whenever properties on a record change.
+  */  
   recordDidChange: function(rec) {
     // add to changed records.  This will eventually notify collections.
     var guid = rec._storeKey() ;