sproutit-sproutcore 1.0.20090721145236 → 1.0.20090721145251

data/frameworks/sproutcore/frameworks/deprecated/tests/views/collection/source_list_rendering.rhtml

@@ -0,0 +1,143 @@
+<% content_for('final') do %>
+<script>
+
+// create some item data...
+[
+  { guid: '1001', name: 'item one', group: '1' },
+  { guid: '1002', name: 'item two', group: '1' },
+  { guid: '1003', name: 'item three', group: '2' },
+  { guid: '1004', name: 'item four', group: '3' },
+  { guid: '1005', name: 'item five', group: '3' },
+  { guid: '1006', name: 'item six', group: '3' }
+].each(function(o){ SC.Store.addRecord(SC.Record.create(o)); });
+
+// a collection to hold the items...
+testCollection = SC.Record.collection();
+testCollection.refresh();
+
+// a controller for the collection...
+testController = SC.CollectionController.create();
+
+Test.context("A grouped SC.SourceListView with its content set to a SC.CollectionController", {
+
+  "Item views should be the same width as the SC.CollectionView": function()
+  {
+    var widthOfFirstItemView = function() {
+      var itemView = testSourceListView.get('itemViews')[0] ;
+      return (itemView) ? itemView.get('frame').width : null ;
+    } ;
+    
+    widthOfFirstItemView().shouldEqual(testSourceListView.get('frame').width) ;
+
+    SC.Store.addRecord( SC.Record.create({ guid: '0999', name: 'item zero', group: '1' }) );
+    
+    widthOfFirstItemView().shouldEqual(testSourceListView.get('frame').width) ;
+  },
+	  
+	"Group views should be the same width as the SC.CollectionView": function()
+	{
+	    var widthOfFirstGroupView = function() {
+	      var groupView = testSourceListView.get('groupViews')[0] ;
+	      return (groupView) ? groupView.get('frame').width : null ;
+	    } ;
+	    
+	    widthOfFirstGroupView().shouldEqual(testSourceListView.get('frame').width) ;
+	},
+	  
+  setup: function()
+  {
+    // add a scroll view wrapper.
+    scrollView = SC.ScrollView.create() ;
+    scrollView.set('frame', { x: 10, y: 10, width: 100, height: 30 }) ;
+    SC.window.appendChild(scrollView) ;
+    
+    // create the view...
+    testSourceListView = SC.SourceListView.create({
+      contentValueKey: 'name',
+      groupBy: 'group',
+      contentBinding: 'testController.arrangedObjects',
+      selectionBinding: 'testController.selection'
+    }) ;
+    scrollView.set('content', testSourceListView) ;
+
+    testController.set('content', testCollection) ;
+    SC.Binding.flushPendingChanges() ;
+  },
+  
+  teardown: function()
+  {
+    // remove the view from SC.window
+    testSourceListView.removeFromParent() ;
+    scrollView.removeFromParent() ;
+    
+    delete testSourceListView ;
+    delete scrollView ;
+    
+    testController.set('content', null) ;
+  }
+  
+});
+
+Test.context("A grouped SC.SourceListView with its content set to a SC.CollectionController, after the containing SC.ScrollView has been resized", {
+  
+
+  "Item views should be the same width as the SC.CollectionView": function()
+  {
+    var widthOfFirstItemView = function() {
+      var itemView = testSourceListView.get('itemViews')[0] ;
+      return (itemView) ? itemView.get('frame').width : null ;
+    } ;
+    
+    widthOfFirstItemView().shouldEqual(testSourceListView.get('frame').width) ;
+
+    SC.Store.addRecord( SC.Record.create({ guid: '0999', name: 'item zero', group: '1' }) );
+    
+    widthOfFirstItemView().shouldEqual(testSourceListView.get('frame').width) ;
+  },
+  
+	"Group views should be the same width as the SC.CollectionView": function()
+	{
+    var widthOfFirstGroupView = function() {
+      var groupView = testSourceListView.get('groupViews')[0] ;
+      return (groupView) ? groupView.get('frame').width : null ;
+    } ;
+    
+    widthOfFirstGroupView().shouldEqual(testSourceListView.get('frame').width) ;
+	},
+  
+  setup: function()
+  {
+    // add a scroll view wrapper.
+    scrollView = SC.ScrollView.create() ;
+    scrollView.set('frame', { x: 10, y: 10, width: 100, height: 30 }) ;
+    SC.window.appendChild(scrollView) ;
+    
+    // create the view...
+    testSourceListView = SC.SourceListView.create({
+      contentValueKey: 'name',
+      groupBy: 'group',
+      contentBinding: 'testController.arrangedObjects',
+      selectionBinding: 'testController.selection'
+    }) ;
+    scrollView.set('content', testSourceListView) ;
+
+    testController.set('content', testCollection) ;
+    SC.Binding.flushPendingChanges() ;
+  },
+  
+  teardown: function()
+  {
+    // remove the view from SC.window
+    testSourceListView.removeFromParent() ;
+    scrollView.removeFromParent() ;
+    
+    delete testSourceListView ;
+    delete scrollView ;
+    
+    testController.set('content', null) ;
+  }
+  
+});
+
+</script>
+<% end %>

data/frameworks/sproutcore/frameworks/deprecated/tests/views/popup_button.rhtml

@@ -0,0 +1,128 @@
+<% content_for('final') do %>
+<script>
+
+
+Test.context("A SC.PopupButtonView with no configured menu", {
+  
+  "Should return null when asked for it's menu": function()
+  {
+    for (var i=0, n=this.buttons.length; i < n; i++)
+    {
+      (buttons[i].get('menu') == null).shouldEqual(true);
+    }
+  },
+  "Should return false if asked to trigger it's action": function()
+  {
+    for (var i=0, n=this.buttons.length; i < n; i++)
+    {
+      this.buttons[i].action().shouldEqual(false);
+    }
+  },
+  "Should not perform keyEquivalents": function()
+  {
+    for (var i=0, n=this.buttons.length; i < n; i++)
+    {
+      this.buttons[i].performKeyEquivalent('alt_shift_z').shouldEqual(false);
+    }
+  },
+  setup: function()
+  {
+    this.buttons = [
+      SC.PopupButtonView.viewFor(null),
+      SC.PopupButtonView.extend({ menuName: '' }).viewFor(null),
+      SC.PopupButtonView.extend({ menuName: 'foobarMenu' }).viewFor(null),
+      SC.PopupButtonView.extend({ menuName: false }).viewFor(null),
+      SC.PopupButtonView.extend({ menuName: null }).viewFor(null) 
+    ];
+  },
+
+  teardown: function()
+  {
+    delete this.buttons;
+  }
+   
+});
+
+
+Test.context("A SC.PopupButtonView with a properly configured menu", {
+  
+  "Should return a menu of the correct type": function()
+  {
+    (this.button.get('menu') != null).shouldEqual(true);
+    this.button.get('menu').kindOf(SC.PopupMenuView).shouldEqual(true);
+  },
+  "Should return true if asked to trigger it's action": function()
+  {
+    this.button.action().shouldEqual(true);
+  },
+  "Should toggle the menu's visibility when triggering the action": function()
+  {
+    // for some reason this actually equals true... not sure why...
+    equals(NO, this.button.get('menu').get('isVisible'), "button.menu.isVisible 1") ;
+    this.button.action();
+    SC.Binding.flushPendingChanges(); // menus use a binding...
+
+    equals(YES, this.button.get('menu').get('isVisible'), "button.menu.isVisible 2") ;
+    this.button.action();
+    SC.Binding.flushPendingChanges(); // menus use a binding...
+
+    equals(NO, this.button.get('menu').get('isVisible'), "button.menu.isVisible 3") ;
+  },
+  "Should have it's isSelected state bound to the menu's visibility": function()
+  {
+    // either by triggering the action...
+    this.button.get('isSelected').shouldEqual(false);
+
+    this.button.action();
+    SC.Binding.flushPendingChanges(); // menus use a binding...
+    this.button.get('isSelected').shouldEqual(true);
+
+    this.button.action();
+    SC.Binding.flushPendingChanges(); // menus use a binding...
+    this.button.get('isSelected').shouldEqual(false);
+
+    // or by showing/hiding the menu...
+    this.button.get('menu').set('isVisible', true);
+    SC.Binding.flushPendingChanges(); // menus use a binding...
+    this.button.get('isSelected').shouldEqual(true);
+    
+    this.button.get('menu').set('isVisible', false);
+    SC.Binding.flushPendingChanges(); // menus use a binding...
+    this.button.get('isSelected').shouldEqual(false);
+  },
+  "Should send performKeyEquivalent messages to it's menu": function()
+  {
+    this.button.get('menu').performKeyEquivalent('alt_shift_z', {}).shouldEqual(true);
+    this.button.performKeyEquivalent('alt_shift_z', {}).shouldEqual(true);
+  },
+  "Should not send performKeyEquivalent messages to it's menu if disabled": function()
+  {
+    this.button.set('isEnabled', false);
+    this.button.performKeyEquivalent('alt_shift_z', {}).shouldEqual(false);
+  },
+  "Should not performKeyEquivalent for disabled menu items": function()
+  {
+    this.button.performKeyEquivalent('alt_shift_d', {}).shouldEqual(false);
+  },
+  setup: function()
+  {
+    this.menu = SC.PopupMenuView.extend({ paneType: "menu" }).create();
+    this.menu.appendChild( SC.MenuItemView.extend({ keyEquivalent: "alt_shift_z" }).create() );
+    this.menu.appendChild( SC.MenuItemView.extend({ keyEquivalent: "alt_shift_d", isEnabled: false }).create() );
+
+    this.button = SC.PopupButtonView.create();
+    this.button.set('menu', this.menu);
+  },
+  teardown: function()
+  {
+    delete this.menu;
+    delete this.button;
+  }
+  
+});
+
+
+
+
+</script>
+<% end %>

data/frameworks/sproutcore/frameworks/deprecated/tests/views/text_field.rhtml

@@ -0,0 +1,37 @@
+<% content_for('final') do %>
+<script>
+
+Test.context("A SC.TextFieldView", {
+  
+  "Should allow text navigation keys when focused": function()
+  {
+    this.field.becomeFirstResponder();
+    this.field.get('isFirstResponder').shouldEqual(true);
+    
+    var keynames = $w('backspace delete home end left right up down');
+    for (var i=0, n=keynames.length; i < n; i++)
+    {
+      // var event = SC.Mock.KeyEvent.create({ 
+      //         type: 'keydown', 
+      //         keyCode: SC.KEY_CODES[ keynames[i] ] 
+      //       });
+      SC.window._onkeydown(event).shouldEqual(true);
+      event.stopped.shouldEqual(false);
+    }
+  },
+
+  setup: function()
+  {
+    this.field = SC.TextFieldView.create();
+    SC.window.appendChild(this.field);
+  },
+  teardown: function()
+  {
+    SC.window.removeChild(this.field);
+    delete this.field;
+  }
+
+});
+
+</script>
+<% end %>

data/frameworks/sproutcore/frameworks/deprecated/views/collection.js

@@ -0,0 +1,24 @@
+// ==========================================================================
+// SproutCore -- JavaScript Application Framework
+// copyright 2006-2008, Sprout Systems, Inc. and contributors.
+// ==========================================================================
+
+SC.mixin( SC.CollectionView.prototype, {
+  
+  // ======================================================================
+  // DEPRECATED APIS (Still available for compatibility)
+  
+  /** @private 
+    If set to false, this method will prevent you from deselecting all of
+    the items in your view.  This is better implemented using a controller
+    that prohibits empty selection.
+  */
+  allowDeselectAll: YES,
+  
+  /** @private */
+  itemExistsInCollection: function(view) { return this.hasItemView(view); },
+  
+  /** @private */
+  viewForContentRecord: function(rec) { return this.itemViewForContent(rec); }
+  
+});

data/frameworks/sproutcore/frameworks/designer/coders/design.js

@@ -0,0 +1,29 @@
+// ========================================================================
+// SproutCore -- JavaScript Application Framework
+// Copyright ©2006-2008, Sprout Systems, Inc. and contributors.
+// Portions copyright ©2008 Apple, Inc.  All rights reserved.
+// ========================================================================
+
+/* evil:true */
+
+sc_require('coders/object');
+
+/** @class
+
+  A DesignCoder encodes specifically the design for a set of views.
+  
+  @extends SC.ObjectCoder
+*/
+SC.DesignCoder = SC.ObjectCoder.extend({
+  extendMethodName: 'design',
+  encodeMethodName: 'encodeDesign'  
+});
+
+/** 
+  Patch SC.View to respond to encodeDesign().  This will proxy to the paired
+  designer, if there is one.  If there is no paired designer, returns NO.
+*/
+SC.View.prototype.encodeDesign = function(coder) {
+  return this.designer ? this.designer.encodeDesign(coder) : NO ;
+};
+

data/frameworks/sproutcore/frameworks/designer/coders/localization.js

@@ -0,0 +1,27 @@
+// ========================================================================
+// SproutCore -- JavaScript Application Framework
+// Copyright ©2006-2008, Sprout Systems, Inc. and contributors.
+// Portions copyright ©2008 Apple, Inc.  All rights reserved.
+// ========================================================================
+
+sc_require('coders/object');
+
+/** @class
+
+  A LocalizationCoder encodes specifically the localization for views.
+  
+  @extends SC.ObjectCoder
+*/
+SC.LocalizationCoder = SC.ObjectCoder.extend({
+  extendMethodName: 'localization',
+  encodeMethodName: 'encodeLoc'
+});
+
+/** 
+  Patch SC.View to respond to encodeDesign().  This will proxy to the paired
+  designer, if there is one.  If there is no paired designer, returns NO.
+*/
+SC.View.prototype.encodeLoc = function(coder) {
+  return this.designer ? this.designer.encodeLoc(coder) : NO ;
+};
+

data/frameworks/sproutcore/frameworks/designer/coders/object.js

@@ -0,0 +1,347 @@
+// ========================================================================
+// SproutCore -- JavaScript Application Framework
+// Copyright ©2006-2008, Sprout Systems, Inc. and contributors.
+// Portions copyright ©2008 Apple, Inc.  All rights reserved.
+// ========================================================================
+
+/**
+
+  Generic base class to encode a view hierarchy.  ViewCoders are used to 
+  collect the properties that may be included in a view design and then to 
+  serialize that design to a JavaScript string that can be evaled.  
+  
+  To encode a view with a ViewCoder, simply call SC.ViewCoder.encode(view).
+  Most of the time, however, you will not initiate coding directly but instead
+  work with the coder while designing an SC.DesignerView subclass.
+
+  h2. Using a Coder
+
+  When you are passed an instance of a coder, you can simply write attributes
+  into the coder using one of the many encoding methods defined on the view.
+  Encoding methods are defined for most primitive view types.
+  
+    coder.string("firstName" , "Charles").string('lastName', 'Jolley');
+  
+  @extends SC.Object
+*/
+SC.ObjectCoder = SC.Object.extend({
+  
+  // ..........................................................
+  // PROPERTIES
+  // 
+  
+  /** The className used to emit the design. */
+  className: 'SC.Object',
+  
+  /** 
+    The method to be used to create the class or object. 
+  */
+  extendMethodName: 'extend',
+  
+  /** 
+    The default encoding method.  If an object defines this method, then a new
+    coder will be created to encode that object.
+  */
+  encodeMethodName: 'encode',
+  
+  /** 
+    The attributes that will be emitted.  The values all must be strings. Use 
+    one of the encoding methods defined below to actually encode attributes.
+  */
+  attributes: null,
+  
+  // ..........................................................
+  // ENCODING METHODS
+  // 
+  // Call these methods to encode various types of attributes.  They all take
+  // the same basic params: (key, value)...
+
+  /**
+    Utility method transforms the passed value with the passed function.  
+    Handles both Arrays and individual items.
+  */
+  transform: function(val, func) {
+    
+    // for an array, transform each value with the func and then return a
+    // combined array.
+    if (SC.typeOf(val) === SC.T_ARRAY) {
+      val = val.map(function(x) { return this.transform(x, func); }, this);
+      val = '['+val+']';
+      
+    // otherwise, just call transform function on the value
+    } else {
+      val = func.call(this, val);
+    }
+    return val;
+  },
+  
+  /**
+    Encodes a string of raw JavaScript.  This is the most primitive method. 
+    You are expected to prep the value yourself.  You can pass an array to
+    this or any other method and it will be encoded as a full array.
+
+    This method also automatically handles null and undefined values.  Null
+    values are included in the output.  Undefined values are ignored.
+    
+    @param key {String} the key to set
+    @param val {String} the JavaScript
+    @param transform {Function} optional transform function to apply to val
+    @returns {SC.ObjectCoder} receiver
+  */
+  js: function(key, val, transform) {
+    
+    // normalize
+    if (val===undefined) { val=key; key = undefined; }
+    val = this.transform(val, function(x) {
+      return (x===null) ? "null" : transform ? transform.call(this, x) : x ;
+    });
+    
+    // save if needed.  Undefined values are ignored
+    if (key !== undefined && (val !== undefined)) {
+      this.attributes[key] = val;
+      return this ;
+    } else return val ;
+  },
+
+  /**
+    Encodes a string, wrapping it in quotes.
+    
+    @param key {String} the key to set
+    @param val {String} the value
+    @returns {SC.ObjectCoder} receiver
+  */
+  string: function(key, val) {
+    return this.js(key, val, function(x) {
+      return '"' + x.replace(/"/g, '\\"') + '"' ;
+    });
+  },
+  
+  /**
+    Encodes a number, wrapping it in quotes.
+    
+    @param key {String} the key to set
+    @param val {Number} the value
+    @returns {SC.ObjectCoder} receiver
+  */
+  number: function(key, val) {
+    return this.js(key, val, function(x) { return x.toString(); });
+  },
+  
+  /**
+    Encodes a bool, mapped as YES or NO
+    
+    @param key {String} the key to set
+    @param val {Boolean} the value
+    @returns {SC.ObjectCoder} receiver
+  */
+  bool: function(key, val) {
+    return this.js(key, val, function(x) { return x ? "YES" : "NO"; });
+  },
+
+  /**
+    Encodes an object.  This will do its best to autodetect the type of the
+    object.  You can pass an optional processing function that will be used 
+    on object members before processing to allow you to normalize.  The 
+    method signature must be:
+    
+      function convert(value, rootObject, key);
+      
+    The rootObject and key will be set to give you the context in the 
+    hierarchy.
+    
+    Generally this method will work for encoding simple value only.  If your 
+    object graph may contain SproutCore objects, you will need to encode it
+    yourself.
+    
+    @param key {String} the key to set
+    @param val {Object} the value
+    @param func {Function} optional transform func
+    @returns {SC.ObjectCoder} receiver
+  */
+  encode: function(key, val, func) {
+    // normalize params
+    if (func===undefined && val instanceof Function) {
+      func = val; val = key; key = undefined; 
+    }
+
+    return this.js(key, val, function(cur) { 
+      if (func) cur = func.call(this, cur, null, null);
+      switch(SC.typeOf(cur)) {
+      case SC.T_STRING:
+        cur = this.string(cur);
+        break;
+
+      case SC.T_NUMBER:
+        cur = this.number(cur);
+        break;
+
+      case SC.T_BOOL:
+        cur = this.bool(cur);
+        break;
+
+      case SC.T_ARRAY:
+        cur = this.array(cur, func) ;
+        break;
+
+      case SC.T_HASH:
+        cur = this.hash(cur, func);
+        break ;
+        
+      default:
+        // otherwise, if the object has a designer attached, try to encode
+        // view.
+        cur = cur ? this.object(cur) : this.js(cur);
+      }
+      return cur ;
+    });
+  },
+  
+  /**
+    Encodes a hash of objects.  The object values must be simple objects for
+    this method to work.  You can also optionally pass a processing function
+    that will be invoked for each value, giving you a chance to convert the
+    value first.  The signature must be (key, value, rootObject).
+    
+    @param key {String} the key to set
+    @param val {Object} the value
+    @param func {Function} optional transform func
+    @returns {SC.ObjectCoder} receiver
+  */
+  hash: function(key, val, func) {
+    
+    // normalize params
+    if (func===undefined && val instanceof Function) {
+      func = val; val = key; key = undefined; 
+    }
+    
+    return this.js(key, val, function(x) { 
+      var ret = [] ;
+      for(var key in x) {
+        if (!x.hasOwnProperty(key)) continue; // only include added...
+        ret.push("%@: %@".fmt(this.encode(key), this.encode(x[key], func)));
+      }
+      return "{%@}".fmt(ret.join(","));
+    });
+  },
+
+  /**
+    Encodes a array of objects.  The object values must be simple objects for
+    this method to work.  You can also optionally pass a processing function
+    that will be invoked for each value, giving you a chance to convert the
+    value first.  The signature must be (index, value, rootObject).
+    
+    @param key {String} the key to set
+    @param val {Object} the value
+    @param func {Function} optional transform func
+    @returns {SC.ObjectCoder} receiver
+  */
+  array: function(key, val, func) {
+    
+    // normalize params
+    if (func===undefined && val instanceof Function) {
+      func = val; val = key; key = undefined; 
+    }
+
+    val = val.map(function(x) { return this.encode(x, func); }, this);
+    val = "[%@]".fmt(val.join(","));
+
+    return this.js(key, val);
+  },
+  
+  /**
+    Attempts to encode an object.  The object must implement the 
+    encodeMethodName for this encoder, or else an exception will be raised.
+    
+    @param key {String} the key to set
+    @param val {Object} the object to encode
+    @returns {SC.ObjectCoder} receiver
+  */
+  object: function(key, val) {
+    return this.js(key, val, function(x) {
+      return this.constructor.encode(x, this);
+    });
+  },
+  
+  // ..........................................................
+  // INTERNAL SUPPORT
+  // 
+  
+  spaces: function() {
+    var spaces = this.context ? this.context.get('spaces') : '' ;
+    spaces = spaces + '  ';  
+    return spaces ;
+  }.property().cacheable(),
+  
+  /** 
+    Emits the final JavaScript output for this coder based on the current
+    attributes.
+  */
+  emit: function() {
+    
+    // return undefined if the encoding was rejected...
+    if (this.invalid) return undefined ;
+    
+    var ret = [], attrs = this.attributes, key ;
+    var methodName = this.get('extendMethodName');
+    var spaces = this.get('spaces');
+    
+    // compute attribute body...
+    for(key in attrs) {
+      if (!attrs.hasOwnProperty(key)) continue ;
+      ret.push("%@: %@".fmt(key, attrs[key]));
+    }
+    
+    if (ret.length <= 0) {
+      return "%@1%@2.%@3({})".fmt(spaces, this.className, methodName);
+    } else {
+      // handle NO class formatting..
+      ret = ret.join(",");
+      return "%@2.%@3({%@4})".fmt(spaces, this.className, methodName, ret);
+    }
+  },
+  
+  /**
+    Begins encoding with a particular object, setting the className to the 
+    object's className.  This is used internally by the encode() method.
+  */
+  begin: function(object) {
+    var methodName = this.get('encodeMethodName');
+    if (SC.typeOf(object[methodName]) !== SC.T_FUNCTION) {
+      throw SC.$error("Cannot encode %@ because it does not respond to %@()".fmt(object, methodName)) ;
+    } 
+    
+    // save className for later coding
+    this.set('className', SC._object_className(object.constructor));
+
+    // then call encode method...
+    var ret = object[methodName](this);
+    
+    // if encoding method returns NO, then encoding is not allowed.
+    // note that returning void should count as YES.
+    this.invalid = ret === NO ;
+    
+    // and return this
+    return this ;
+  },
+  
+  init: function() {
+    sc_super();
+    this.set('attributes', {});
+  },
+  
+  destroy: function() {
+    sc_super();
+    this.context = this.className = this.attributes = null ; // cleanup
+  }
+  
+});
+
+SC.ObjectCoder.encode = function(object, context) {
+  // create coder and emit code...
+  var coder = this.create({ context: context });
+  var ret = coder.begin(object).emit();
+  
+  // cleanup and return
+  coder.destroy();
+  return ret ;
+} ;