sproutcore 0.9.0

data/frameworks/sproutcore/models/store.js

@@ -0,0 +1,295 @@
+// ========================================================================
+// SproutCore
+// copyright 2006-2007 Sprout Systems, Inc.
+// ========================================================================
+
+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({
+  
+  // 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.
+  updateRecords: function(dataHashes, dataSource, recordType, isLoaded) {
+    
+    this.set('updateRecordsInProgress',true) ;
+    var store = this ; 
+    var ret = [] ;
+    if (!recordType) recordType = SC.Record ;
+    this.beginPropertyChanges() ;
+
+    //SC.Benchmark._bench(function() { 
+    dataHashes.each(function(data) {
+      var rt = data.recordType || recordType; 
+      if (data.recordType !== undefined) delete data.recordType;
+      
+      var pkValue = data[rt.primaryKey()] ;      
+      var rec = store.getRecordFor(pkValue,rt,true) ;
+      rec.dataSource = dataSource ;
+      rec.updateAttributes(data, isLoaded, isLoaded) ;
+      if (rec.needsAddToStore) store.addRecord(rec) ;
+      ret.push(rec) ;
+    });
+//    },'dataHashes') ;  
+
+    this.endPropertyChanges() ;
+    this.set('updateRecordsInProgress',false) ;
+    return ret ;
+  },
+
+  // ....................................
+  // Record dataSource methods
+  //
+
+  refreshRecords: function(records) {},
+  
+  createRecords: function(recs) {
+    recs.invoke('set','newRecord','false') ;
+    this.commitRecords(recs); 
+  },
+  
+  commitRecords: function(recs) { recs.invoke('set','isDirty','false'); },
+  
+  destroyRecords: function(recs) {
+    var store = this ;
+    recs.each(function(r) { 
+      r.set('isDeleted',true); store.removeRecord(r);
+    });
+  },
+  
+  // ....................................
+  // Record Helpers
+  //
+  
+  // 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;
+    var guid = rec._storeKey();
+    var records = this._records[guid] || [];
+    records.push(rec);
+    this._records[guid] = records; 
+
+    // global record cache
+    if (!this._quickCache) this._quickCache = {};
+
+    // records are cached by Class type
+    var records = this._quickCache[guid] || {};
+    var pkey = rec.get(rec.primaryKey);
+    records[pkey] = rec;
+    this._quickCache[guid] = records;
+
+    // and start observing it.
+    rec.addObserver('*',this._boundRecordObserver) ;
+    this.recordDidChange(rec) ;
+  },
+
+  // 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();
+    var records = this._records[guid] || [];
+    records = records.without(rec);
+    this._records[guid] = records;
+    
+    // remove from quick cache
+    if (this._quickCache)
+    {
+      var records = this._quickCache[guid] || {};
+      var pkey = rec.get(rec.primaryKey);
+      delete records[pkey];
+      this._quickCache[guid] = records;
+    }
+
+    // and stop observing it.
+    rec.removeObserver('*',this._boundRecordObserver) ;
+    this.recordDidChange(rec) ; // this will remove from cols since destroyed.
+  },
+
+  /**
+  * 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
+  **/
+  relocateRecord: function( oldkey, newkey, rec )
+  {
+    if (!this._quickCache) return rec;
+    
+    var classKey = rec._storeKey();
+    var records  = this._quickCache[classKey] || {};
+
+    records[newkey] = rec;
+    delete records[oldkey];
+    
+    this._quickCache[classKey] = records;
+    
+    return rec;
+  },
+
+
+  // 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() ;
+    var guid = recordType._storeKey() ;
+
+    // initial set of records.
+    var records = this._records[guid] ;
+    
+    while(allConditions.length > 0) {
+      var conditions = allConditions.pop() ;
+      var ret = [] ; var loc = (records) ? records.length : 0;
+      while(--loc >= 0) {
+        var rec = records[loc] ;
+        if ((rec._type == recordType) || (rec._type.coreRecordType == recordType)) {
+          if (rec.matchConditions(conditions)) ret.push(rec) ;
+        }
+      }
+      records = ret ;
+    }
+    
+    return records ;
+  },
+  
+  // private method used by Record and Store. Returns null if the record does not exist.
+  _getRecordFor: function(pkValue,recordType) {
+    var guid = recordType._storeKey() ;
+    var records = (this._quickCache) ? this._quickCache[guid] : null;
+    var ret = (records) ? records[pkValue] : null ;
+    return ret ;
+  },
+  
+  // 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) {
+      var opts = {}; opts[recordType.primaryKey()] = pkValue;
+      ret = recordType.create(opts) ;
+      if (dontAutoaddRecord) {
+        ret.needsAddToStore = true ;
+      } else this.addRecord(ret) ;
+    }
+    return ret ;
+  },
+  
+  // ....................................
+  // Collection Helpers
+  //
+  
+  addCollection: function(collection) {
+    var guid = collection.recordType._storeKey() ;
+    var collections = this._collections[guid] || [] ;
+    collections.push(collection) ;
+    this._collections[guid] = collections ;
+  },
+  
+  removeCollection: function(collection) {
+    var guid = collection.recordType._storeKey() ;
+    var collections = this._collections[guid] || [] ;
+    collections = collections.without(collection) ;
+    this._collections[guid] = collections ;
+  },
+  
+  listFor: function(opts) {
+    var conditions = opts.conditions || {} ;
+    var order = opts.order || ['guid'] ;
+    var records = this.findRecords(conditions,opts.recordType) ;
+    var count = records.length ;
+
+    // sort
+    records = records.sort(function(a,b) { return a.compareTo(b,order); }) ;
+    
+    // slice if needed.
+    if (opts.limit && (opts.limit > 0)) {
+      var start = (opts.offset) ? opts.offset : 0 ;
+      var end = start + opts.limit ;
+      records = records.slice(start,end) ;      
+    }
+    
+    // now run callback.
+    if (opts.callback) opts.callback(records,count) ; 
+  },
+  
+  // ....................................
+  // PRIVATE
+  //
+  _records: {}, _changedRecords: null, _collections: {},
+  
+  // called whenever properties on a record change.
+  recordDidChange: function(rec) {
+    // add to changed records.  This will eventually notify collections.
+    var guid = rec._storeKey() ;
+    changed = this.get('_changedRecords') || {};
+    records = changed[guid] || {} ;
+    records[rec._guid] = rec ;
+
+    changed[guid] = records ;    
+    this.set('_changedRecords',changed) ;
+  },
+  
+  // invoked whenever the changedRecords hash is updated. This will notify
+  // collections.
+  _changedRecordsObserver: function() { 
+    // process changedRecords to notify collections.
+    for(var guid in this._changedRecords) {
+      var collections = this._collections[guid] ;
+      if (collections && collections.length>0) {
+        
+        // collect records into array.  Faster than using uniq.
+        var records = [] ;
+        for(var key in this._changedRecords[guid]) {
+          records.push(this._changedRecords[guid][key]) ;
+        }
+        var cloc = collections.length ;
+        while(--cloc >= 0) {
+          
+          // for each collection watching this type of record, notify.
+          var col = collections[cloc] ;
+          col.beginPropertyChanges() ;
+          try {
+            // for each record...
+            var rloc = records.length ;
+            while(--rloc >= 0) {
+              var record = records[rloc] ;
+              // notify only if record type matches.
+              if (col.recordType == record._type) {
+                col.recordDidChange(record) ;
+              }
+            }
+          }
+          catch (e) {
+            console.log('EXCEPTION: While notifying collection') ;
+          }
+          col.endPropertyChanges() ;
+          
+        }
+      }
+    }
+    
+    // then clear changed records to start again.
+    this._changedRecords = {} ;
+    
+  }.observes('_changedRecords'),
+  
+  init: function() {
+    arguments.callee.base.call(this) ;
+    this._boundRecordObserver = this.recordDidChange.bind(this) ;
+  }
+    
+}) ;

data/frameworks/sproutcore/panes/dialog.js

@@ -0,0 +1,16 @@
+// ========================================================================
+// SproutCore
+// copyright 2006-2007 Sprout Systems, Inc.
+// ========================================================================
+
+require('panes/overlay') ;
+
+SC.DIALOG_PANE = 'dialog';
+SC.DialogPaneView = SC.OverlayPaneView.extend({
+  
+  emptyElement: '<div class="pane dialog-pane"><div class="pane-wrapper"><div class="pane-root"></div></div>',
+  
+  layer: 200
+
+}) ;
+

data/frameworks/sproutcore/panes/manager.js

@@ -0,0 +1,164 @@
+// ========================================================================
+// SproutCore
+// copyright 2006-2007 Sprout Systems, Inc.
+// ========================================================================
+
+require('views/view') ;
+
+// The PaneManager is responsible for displaying pane that appear over your
+// regular content.  You can register your own pane types by calling 
+// PaneManager.registerPane('type',PaneClass) on app load.
+//
+// One instance of the PaneManager view is created the first time you try
+// to show a pane.
+SC.PaneManager = SC.View.extend({
+
+  emptyElement: '<div id="panes"></div>',
+  
+  // this method will show a pane.  Pass the content view and the paneType.
+  // if the pane is already visible, it will be hidden first.  The optional
+  // event and root element will be set as properties on the wrapper pane
+  // before the pane is made visible so that it can position itself.
+  showPaneView: function(view, paneType, anchorView, triggerEvent) {
+
+    // if pane is already showing, hide the pane first...
+    this.hidePaneView(view) ;
+    
+    // now get a pane instance for the specified paneType and add view to it.
+    var pane = this.getPaneFor(paneType) ;
+    pane._managedPaneType = paneType ;
+    pane.set('anchorView',anchorView) ;
+    pane.set('triggerEvent',triggerEvent) ;
+    pane.set('isVisible', false) ;
+    this._visiblePanes[view._guid] = pane ;
+    
+    // look through child views (which are panes).  Insert before first pane
+    // with a layer value > this pane.
+    var child= this.get('firstChild') ;
+    var layer = pane.get('layer');
+    while(child && (child.get('layer') <= layer)) {
+      child = child.get('nextSibling');
+    }
+
+    this.insertBefore(pane, child);
+
+    // if this pane is not visible, make it visible too.
+    this.set('isVisible',true) ;
+    
+    // and make target pane visible, but set visibility hidden.
+    // visibility hidden will be turned off when the view is fully configured.
+    pane.setStyle({ visibility: 'hidden' }) ;
+    pane.set('isVisible',true) ;
+
+    
+    this._setApplicationKeyPane();
+
+    // set content on view.
+    pane.set('content',view);
+  },
+  
+  // this method will hide a visible pane view.  Pass the content view. If
+  // the view is not already visible, this will do nothing.
+  hidePaneView: function(view) {
+    var pane = this._visiblePanes[view._guid] ;
+    if (!pane) return ;
+    
+    // make pane not visible then do the rest of the cleanup when that
+    // finishes.
+    pane.addObserver('displayIsVisible', this._boundPaneDidHide) ;
+    pane.set('isVisible', false) ;
+  },
+
+  // this method will return a pave view for the specified type.  If no panes
+  // of the type exist in the pane cache, then a new pane will be created.
+  getPaneFor: function(paneType) {
+    var panes = this._paneCache[paneType] ;
+    var pane = (panes) ? panes.pop() : null ;
+    if (pane) return pane ;
+    
+    // no pane found in cache.  Build one instead.  First look for class in
+    // set of registered pane types.  If that doesn't work, build class name.
+    var paneClass = this._paneTypes[paneType] ;
+    if (!paneClass) paneClass = SC[paneType.classify() + 'PaneView'] ;
+    if (!paneClass) {
+      throw "no matching class found for pane type '%@'".fmt(paneType);
+    }
+    
+    // now create an instance.
+    pane = paneClass.viewFor(null) ;
+    return pane ;
+  },
+  
+  // this method will add the pane instance to the pane cache for later use.
+  returnToCache: function(pane, paneType) {
+    var panes = this._paneCache[paneType] || [] ;
+    panes.push(pane) ;
+    this._paneCache[paneType] = panes;   
+  },
+  
+  // this method is called by the pane when it finishes hiding itself.
+  _paneDidHide: function(pane) {
+    var visible = pane.get('displayIsVisible') ;
+    if (visible) return ;
+    
+    // remove this observer and remove pane from parent view.
+    pane.removeObserver('displayIsVisible', this._boundPanelDidHide) ;
+    pane.removeFromParent() ;
+
+    // now remove content view from pane and return pane to cache.
+    pane.set('content', null) ;
+    this.returnToCache(pane,pane._managedPaneType) ;
+    
+    // if there are no more panes left visible, hide pane manager as well.
+    if (this.get('firstChild') == null) {
+      this.set('isVisible',false) ;
+    }
+    
+    this._setApplicationKeyPane();
+  },
+  
+  /**
+  * @todo Need to move this (and all of the pane display/hide interface) into SC.Application
+  */
+  _setApplicationKeyPane: function()
+  {
+    // ensure that the frontmost pane is the key pane
+    // we're making a lot of assumptions here... need to create a some unit tests that:
+    //    lastChild is always a pane view
+    //    calling makeKeyPane indiscriminately will have no ill effect (currently it's fine)
+    var frontMostPane = this.get('lastChild');
+    if (frontMostPane && frontMostPane.get('isVisible')) {
+      frontMostPane.makeKeyPane();
+    } else {
+      var pane = SC.app.get('mainPane');
+      if (pane) pane.makeKeyPane();
+    }
+  },
+  
+  // on init, add to main HTML page if not already added.
+  init: function() {
+    arguments.callee.base.apply(this,arguments) ;
+    var el = this.rootElement ;
+    if (!this.parentNode) {
+      $tag('body').insertBefore(el, null) ;
+      SC.window.insertBefore(this, null) ;
+    }
+    this.set('isVisible',false) ;
+    this._boundPaneDidHide = this._paneDidHide.bind(this) ;
+  },
+  
+  // registered panes.
+  _paneTypes: {},
+  _paneCache: {}, // unused pane instances stored by paneType.
+  _visiblePanes: {} // panes stored by views
+}) ;
+
+SC.PaneManager.registerPaneType = function(paneType, paneClass) {
+  SC.PaneManager.prototype._paneTypes[paneType] = paneClass ;  
+} ;
+
+// This will create the manager instance if it does not already exist.
+SC.PaneManager.manager = function() {
+   if (!this._manager) this._manager = SC.PaneManager.viewFor('panes') ;
+   return this._manager ;
+}; 

data/frameworks/sproutcore/panes/menu.js

@@ -0,0 +1,45 @@
+// ========================================================================
+// SproutCore
+// copyright 2006-2007 Sprout Systems, Inc.
+// ========================================================================
+
+require('panes/overlay') ;
+
+SC.MENU_PANE = 'menu';
+SC.MenuPaneView = SC.OverlayPaneView.extend({
+
+  emptyElement: '<div class="pane menu-pane"><div class="shadow pane-wrapper"><div class="pane-root"></div><div class="top-left-edge"></div><div class="top-edge"></div><div class="top-right-edge"></div><div class="right-edge"></div><div class="bottom-right-edge"></div><div class="bottom-edge"></div><div class="bottom-left-edge"></div><div class="left-edge"></div></div></div>',
+
+  layer: 400,
+
+  isModal: false,
+  
+  // The ideal position for a picker pane is just below the anchor that 
+  // triggered it.  Find that ideal position, then call adjustPosition.
+  positionPane: function() {
+    var anchor = this.anchorView ;
+    var picker = this.containerView ;
+    var origin ;
+    
+    // usually an anchorView will be passed.  The ideal position to appear is
+    // just below the anchorView.  If that is not possible, fitToScreen will
+    // take care of that.
+    if (anchor) {
+      origin = picker.convertFrameFromView(anchor.get('frame'), anchor) ;
+      origin.y += origin.height ;
+      origin = this.fitPositionToScreen(origin, picker, anchor) ;
+      
+    // if no anchor view has been set for some reason, just center.
+    } else {
+      var wsize = SC.window.get('size') ;
+      var psize = picker.get('size') ;
+      origin = {} ;
+      origin.x = (wsize.width - psize.width) / 2 ;
+      origin.y = (wsize.height - psize.height) / 2 ;
+    }
+    
+    picker.set('origin',origin) ;
+  }
+  
+}) ;
+