sproutit-sproutcore 1.0.0.20090407205609 → 1.0.0.20090408130025

data/frameworks/sproutcore/frameworks/deprecated/system/binding.js

@@ -0,0 +1,36 @@
+// ......................................
+// DEPRECATED
+//
+// The transforms below are deprecated but still available for backwards 
+// compatibility.  Instead of using these methods, however, you should use
+// the helpers.  For example, where before you would have done:
+//
+//  contentBinding: SC.Binding.Single('MyApp.myController.count') ;
+//
+// you should do:
+//
+//  contentBinding. SC.Binding.from('MyApp.myController.count').single();
+//
+// and for defaults:
+//
+//  contentBindingDefault: SC.Binding.single()
+//
+SC.Binding.From = SC.Binding.NoChange = SC.Binding.builder();
+
+SC.Binding.Single = SC.Binding.single().builder() ;
+SC.Binding.SingleNull = SC.Binding.single(null).builder() ;
+SC.Binding.SingleNoError = SC.Binding.Single.beget().noError().builder() ;
+SC.Binding.SingleNullNoError = SC.Binding.SingleNull.beget().noError().builder() ;
+SC.Binding.Multiple = SC.Binding.multiple().builder() ;
+SC.Binding.MultipleNoError = SC.Binding.multiple().noError().builder() ;
+
+SC.Binding.Bool = SC.Binding.bool().builder() ;
+SC.Binding.Not = SC.Binding.bool().not().builder() ;
+SC.Binding.NotNull = SC.Binding.isNull().not().builder() ;
+SC.Binding.IsNull = SC.Binding.isNull().builder() ;
+
+// No Error versions.
+SC.Binding.BoolNoError = SC.Binding.Bool.beget().noError().builder();
+SC.Binding.NotNullNoError = SC.Binding.NotNull.beget().noError().builder();
+SC.Binding.NotNoError = SC.Binding.Not.beget().noError().builder();
+SC.Binding.IsNullNoError = SC.Binding.IsNull.beget().noError().builder() ;

data/frameworks/sproutcore/frameworks/deprecated/system/browser.js

@@ -0,0 +1,77 @@
+// ========================================================================
+// SproutCore -- JavaScript Application Framework
+// Copyright ©2006-2008, Sprout Systems, Inc. and contributors.
+// Portions copyright ©2008 Apple, Inc.  All rights reserved.
+// ========================================================================
+
+require('system/browser');
+
+/**
+  @deprecated
+  
+  API for detecting the current browser and platform.  It is recommended that
+  you use the new SC.browser object instead as it does not require a function
+  call.
+*/
+SC.mixin({
+  Platform: {
+    /** The current IE version number or 0 if not IE. */
+    IE: SC.browser.msie,
+    /** The current Safari major version number of 0 if not Safari */
+    Safari: SC.browser.safari,
+    /** The current Firefox major version number or 0 if not Firefox */
+    Firefox: SC.browser.mozilla,    
+    isWindows: SC.browser.isWindows,
+    isMac: SC.browser.isMac
+  },
+
+  // DEPRECATED.  here for compatibility only.
+  /** @private */
+  isIE: function() { 
+    return SC.browser.msie > 0 ;
+  },
+
+  /** @private */
+  isSafari: function() {
+    return SC.browser.safari > 0 ;
+  },
+
+  /** @private */
+  isSafari3: function() {
+    return SC.browser.safari >= 3 ;
+  },
+
+  /** @private */
+  isIE7: function() {
+    return SC.browser.msie >= 7 ;
+  },
+
+  /** @private */
+  isIE6: function() {
+    return (SC.browser.msie >= 6) && (SC.browser.msie < 7) ;
+  },
+
+  /** @private */
+  isWindows: function() {
+    return SC.browser.isWindows;
+  },
+
+  /** @private */
+  isMacOSX: function() {
+    return SC.browser.isMac ;
+  },
+
+  /** @private */
+  isFireFox: function() {
+    return SC.browser.mozilla > 0 ;
+  },
+
+  /** @private */
+  isFireFox2: function() {
+    return SC.browser.mozilla >= 2 ;
+  },
+  
+  // Save the Platform.Browser name.
+  Browser: ((SC.browser.msie) ? "IE" : (SC.browser.safari) ? "Safari" : (SC.browser.mozilla) ? "Firefox" : null)
+  
+});

data/frameworks/sproutcore/frameworks/deprecated/system/classic_responder.js

@@ -0,0 +1,314 @@
+// ========================================================================
+// SproutCore -- JavaScript Application Framework
+// Copyright ©2006-2008, Sprout Systems, Inc. and contributors.
+// Portions copyright ©2008 Apple, Inc.  All rights reserved.
+// ========================================================================
+
+require('core') ;
+require('system/object') ;
+require('application/input_manager');
+
+/**
+  @class 
+  
+  A responder is capable of responding to events such as mouse clicks and key 
+  presses.  
+  
+  All views are a type of responder, but you can extend this class yourself 
+  as well to implement your own responders if you need to.
+  
+  @extends SC.Object
+  
+*/
+SC.ClassicResponder = SC.Object.extend(
+  /** @scope SC.ClassicResponder.prototype */
+  {
+    
+  // .......................................................................
+  // Managing Responder States
+  //
+  
+  /**  
+    This method will be called just before you become first responder to see
+    if you want to be first responder.  If you don't want to handle
+    keyboard events, return false. (this is the default).  Note that this is
+    a property.
+  */
+  acceptsFirstResponder: false,
+  
+  /**
+    This property is the next responder that should be allowed to handle
+    events if you don't want to handle it.  For views, this is automatically
+    set to your parentNode.
+  */
+  nextResponder: null,
+  
+  /**  
+    This property is true whenever you are the first responder.  Observable.
+  */
+  isFirstResponder: false,
+
+  pane: null,
+  
+  /**
+    Call this method to become the first responder.  You will now be the
+    first to receive keyboard events, etc.  Return false if you could not
+    be made first responder for some reason.
+  */
+  becomeFirstResponder: function()
+  {
+    if (!this.get('acceptsFirstResponder')) return false; // responder doesn't want it
+
+    var pane = this.get('pane');
+    if (!pane) return false;                              // there's no pane of which to become FR.. doesn't matter if it *does* want it...
+
+    if (pane.get('firstResponder') == this) return true;  // we already got it... and setting it again will trigger the willResign callback
+
+    pane.set('firstResponder',this);
+    return true;
+  },
+  
+  /**
+    Call this method if you no longer want to be first responder.  Normally
+    you don't need to do this since you will lose firstResponder status
+    when the user focuses a different view.
+  */
+  resignFirstResponder: function()
+  {
+    var pane = this.get('pane');
+    if (!pane) return false;
+    
+    if (pane.get('firstResponder') != this) return false;
+    
+    pane.set('firstResponder',null);
+    return true;
+  },
+  
+  noResponderFor: function() {},
+  
+  /**
+    This method will be called just before you become the first responder
+    so you can make changes.
+  */
+  didBecomeFirstResponder: function() {},
+  
+  /**
+    This method will be called just before you lose first responder status.
+  */
+  willLoseFirstResponder: function() {},
+
+
+  // .......................................................................
+  // Keyboard Events
+  //
+  
+  /**
+    Set this value to an SC.InputManager instance if you want to use a 
+    custom input manager for this specific instance.  If you want to override
+    the input manager used for all responders, replace SC.ClassicResponder.inputManager.
+  */
+  inputManager: function()
+  {
+    return SC.ClassicResponder.inputManager;
+  }.property(),
+
+  /**
+    this method is invoked on the firstResponder whenever the user presses
+    a key.  You can interpret this yourself or call interpretKeyEvents()
+    which will use the inputManager to handle the event.  The default
+    version just passes this onto the next responder.
+  */
+  keyDown: function(evt) {
+    var nr = this.get('nextResponder') ;
+    return (nr && nr.keyDown) ? nr.keyDown(evt) : false;
+  },
+  
+  /**  
+    This method is invoked on the firstResponder whenever the user releases
+    a key.  Default version just passes onto the next responder.
+  */
+  keyUp: function(evt) {
+    var nr = this.get('nextResponder') ;
+    return (nr && nr.keyUp) ? nr.keyUp(evt) : false ;
+  },
+  
+  /**  
+    This method is invoked whenever the user changes the flag keys that are
+    pressed.  pressedFlags is a hash.  The default version passes on to the
+    nextRespoonder.
+  */
+  flagsChanged: function(pressedFlags, evt) {
+    //var nr = this.get('nextResponder') || SC.window.get('firstResponder') ;
+    var nr = this.get('nextResponder') ;
+    return (nr && nr.flagsChanges) ? nr.flagsChanges(pressedFlags, evt) : false;
+  },
+
+  /**
+    This will be called if a keydown event isn't handled by the responder chain.
+  */
+  performKeyEquivalent: function(keystring, evt) {
+    return false;
+  },
+
+  /*
+    call this method with one or more event objects to process the incoming
+    text.  This will use the current inputManager (see above) to process
+    the event and then to make an appropriate call on the receiver.
+  */
+  interpretKeyEvents: function(evts) {
+    var inputManager = this.get('inputManager');
+    if (inputManager) return inputManager.interpretKeyEvents(evts, this) ;
+    return false ;
+  },
+
+  /**
+  * Attempt to perform a method. If either the method does not exist, or the method returns false, send the request to the nextResponder.
+  * @param {String} method The name of the method to perform
+  * @return {SC.ClassicResponder} The responder that handled the command, or false
+  */
+  doCommand: function(method)
+  {
+    var responder = this;
+    var args      = SC.$A(arguments);
+    var aliases   = this._commandAliases[method];
+    var handled   = false;
+    method    = args.shift();
+    
+    do {
+      // attempt to handle the method
+      if (this._responderHandledCommand(responder, method, args)) return responder;
+      // perhaps under an alias?
+      if (aliases)
+      {
+        for (var i=0, n=aliases.length; i < n; i++)
+        {
+          if (this._responderHandledCommand(responder, aliases[i], args)) return responder;
+        }
+      }
+      // nope... next responder, please...
+    } while (responder = responder.get('nextResponder'));
+    // ran out of responders... 
+    return false;
+  },
+  
+  /** @private */
+  _responderHandledCommand: function( responder, method, args )
+  {
+    // if the method does not explicitly return a false-y value (false, "", 0), it's considered "handled"
+    // WARNING: returning null, or void is *not* == false
+    return (responder.respondsTo(method) && (responder[method].apply(responder, args) !== false));
+  },
+  /** @private */
+  _commandAliases: {
+    'mouseDown':   ['didMouseDown'],
+    'mouseUp':     ['didMouseUp'],
+    'doubleClick': ['didDoubleClick'],
+    'click':       ['didClick'],
+    'mouseDown':   ['didMouseDown']
+  }
+
+  // .......................................................................
+  // Mouse Event Handlers
+  //
+  // Implement any of these if you want them to be implemented.
+  
+  // when the mouse is pressed.
+  // mouseDown: function(evt) {},
+  
+  // when the mouse is releases
+  // mouseUp: function(evt) {},
+  
+  // when the mouse is dragged
+  // mouseDragged: function(evt) {},
+  
+  // when the mouse leaves the view responder
+  // mouseOut: function(evt) {},
+  
+  // when the mouse enters the view.
+  // mouseOver: function(evt) {},
+  
+  // when the mouse is moved.
+  // mouseMoved: function(evt) {},
+  
+  // .......................................................................
+  // Event Handlers
+  //
+  // These methods are called by the input manager in response to keyboard
+  // events.  Most of these methods are defined here for you, but not actually
+  // implemented in code.
+
+  // insert the text or act on the key.
+  // insertText: function(text) {},
+  
+  // if the user presses a key-combination event, this will be called so you
+  // can run the command. 
+  // performKeyEquivalent: function(charCode, evt) { return false; },
+  
+  // this method is called if no other view in the current view hierarchy is
+  // bound to the escape or command-. key equivalent.  You can use this to 
+  // cancel whatever operation is running.
+  //
+  // cancel: function(sender, evt) {},
+
+  // delete the current selection or delete one element backward from the
+  // current selection.
+  // deleteBackward: function(sender, evt) {},
+  
+  // delete the current selection or delete one element forward from the
+  // current selection.
+  // deleteForward: function(sender, evt) {},
+  
+  // a field editor might respond by selecting the field before it.
+  // insertBacktab: function(sender, evt) {},
+  
+  // insert a newline character or end editing of the receiver.
+  // insertNewline: function(sender, evt) {},
+  
+  // insert a tab or move forward to the next field.
+  // insertTab: function(sender, evt) {},
+  
+  // move insertion point/selection backward one. (i.e. left arrow key)
+  // moveLeft: function(sender, evt) {},
+  
+  // move the insertion point/selection forward one (i.e. right arrow key)
+  // in left-to-right text, this could be the left arrow key.
+  // moveRight: function(sender, evt) {},
+  
+  // move the insertion point/selection up one (i.e. up arrow key)
+  // moveUp: function(sender, evt) {},
+  
+  // move the insertion point/selection down one (i.e. down arrow key)
+  // moveDown: function(sender, evt) {},
+  
+  // move left, extending the selection. - shift || alt
+  // moveLeftAndModifySelection: function(sender, evt) {},
+  
+  // move right, extending the seleciton - shift || alt
+  // moveRightAndModifySelection: function(sender, evt) {},
+  
+  // move up, extending the selection - shift || alt
+  // moveUpAndModifySelection: function(sender, evt) {},
+  
+  // move down, extending selection - shift || alt
+  // moveDownAndModifySelection: function(sender, evt) {},
+  
+  // move insertion point/selection to beginning of document.
+  // moveToBeginningOfDocument: function(sender, evt) {},
+  
+  // move insertion point/selection to end of document.
+  // moveToEndOfDocument: function(sender, evt) {},
+  
+  // page down
+  // pageDown: function(sender, evt) {},
+  
+  // page up
+  // pageUp: function(sender, evt) {},
+  
+  // select all
+  // selectAll: function(sender, evt) {},
+  
+});
+
+SC.ClassicResponder.mixin({
+  inputManager: SC.Object.create()
+}) ;

data/frameworks/sproutcore/frameworks/deprecated/system/event.js

@@ -0,0 +1,60 @@
+// ========================================================================
+// SproutCore -- JavaScript Application Framework
+// Copyright ©2006-2008, Sprout Systems, Inc. and contributors.
+// Portions copyright ©2008 Apple, Inc.  All rights reserved.
+// ========================================================================
+
+require('system/event') ;
+
+// This file defines some basic extensions to the built-in Event object to
+// provide some common utility functions.
+
+SC.mixin(SC.Event, /** @scope SC.Event */ {
+
+  /** @deprecated 
+    Returns the character code for the passed event.  This is no longer needed
+    as you can now use the .which property on the event itself.
+  */
+  getCharCode: function(e) {
+    return (e.keyCode) ? e.keyCode : ((e.which)?e.which:0) ; 
+  },
+  
+  /** @deprecated 
+    Returns the pressed character as a string.  You should instead use the
+    getCharString() method defined on the event itself.
+  */
+  getCharString: function(e) {
+    return String.fromCharCode(Event.getCharCode(e)) ;
+  },
+  
+  /** @deprecated 
+    Returns the pointer location on the page for the passed event.  You should
+    now use the pageX and pageY properties on the event instead.
+  */
+  pointerLocation: function(event) {
+    var ret = {
+      x: event.pageX || (event.clientX +
+        (document.documentElement.scrollLeft || document.body.scrollLeft)),
+      y: event.pageY || (event.clientY +
+        (document.documentElement.scrollTop || document.body.scrollTop))
+      
+    };
+    return ret ;
+  },
+  
+  /** @deprecated
+    Stops an event both from performing the default action and from bubbling.
+    Instead all event.stop() directly on the event.
+  */
+  stop: function(event) { return event.stop() ;},
+  
+  ALT_KEY: '_ALT',
+  CTRL_KEY: '_CTRL',
+  SHIFT_KEY: '_SHIFT'
+    
+});
+
+// These enhancements were once provided on the native Event class also.
+"getCharCode getCharString pointerLocation ALT_KEY CTRL_KEY SHIFT_KEY".split(' ').forEach(function(key){
+  Event[key] = SC.Event[key] ;
+}) ;

data/frameworks/sproutcore/frameworks/deprecated/system/globals.js

@@ -0,0 +1,20 @@
+// ========================================================================
+// SproutCore -- JavaScript Application Framework
+// Copyright ©2006-2008, Sprout Systems, Inc. and contributors.
+// Portions copyright ©2008 Apple, Inc.  All rights reserved.
+// ========================================================================
+
+// Globally defined variables are no longer supported to allow SproutCore to 
+// work with other libraries.
+// Export the type variables into the global space.
+var T_ERROR = SC.T_ERROR ;
+var T_OBJECT = SC.T_OBJECT ;
+var T_NULL = SC.T_NULL ;
+var T_CLASS = SC.T_CLASS ;
+var T_HASH = SC.T_HASH ;
+var T_FUNCTION = SC.T_FUNCTION ;
+var T_UNDEFINED = SC.T_UNDEFINED ;
+var T_NUMBER = SC.T_NUMBER ;
+var T_BOOL = SC.T_BOOL ;
+var T_ARRAY = SC.T_ARRAY ;
+var T_STRING = SC.T_STRING ;

data/frameworks/sproutcore/frameworks/deprecated/system/misc.js

@@ -0,0 +1,60 @@
+// ========================================================================
+// SproutCore -- JavaScript Application Framework
+// Copyright ©2006-2008, Sprout Systems, Inc. and contributors.
+// Portions copyright ©2008 Apple, Inc.  All rights reserved.
+// ========================================================================
+
+require('application/routes') ;
+
+// Legacy.  Will retire.
+SC.mixin(Object,
+/** @scope Object */ {
+
+  /** @deprecated
+   Serialize a general JSON object into a URI.  This method of encoding is 
+   no longer supported or recommended.
+  */
+  serialize: function(obj) {
+    var ret = [] ;
+    for(var key in obj) {
+      var value = obj[key] ;
+      if (typeof value == 'number') { value = '' + value ; }
+      if (!(typeof value == 'string')) { value = value.join(','); }
+      ret.push(encodeURIComponent(key) + "=" + encodeURIComponent(value)) ;
+    }
+    return ret.join('&') ;
+  }
+  
+}) ;
+
+/** @deprecated
+  This will add or remove the class name based on the flag, allowing you to
+  treat it like a bool setting.  Simplifies the common case where you need
+  to make a class name match a bool.
+  
+  Since SproutCore no long requires the Prototype library, this extension to
+  Prototype is also no longer supported.  You can use setClassName() on 
+  SC.ClassicView, or the sproutcore-jquery framework instead.
+*/
+Element.setClassName = function(element,className,flag) {
+  if(SC.browser.isIE)
+  {
+    if (flag) { 
+      Element.addClassName(element,className); 
+    } else {
+      Element.removeClassName(element,className) ;
+    }
+  } 
+  else
+  {
+    if (flag) { 
+      element.addClassName(className); 
+    } else {
+      element.removeClassName(className) ;
+    }
+  } 
+} ;
+
+
+SC.Routes = SC.routes;
+SC.Routes.addRoute = SC.routes.add;

data/frameworks/sproutcore/frameworks/deprecated/system/node_descriptor.js

@@ -0,0 +1,72 @@
+// ========================================================================
+// SproutCore -- JavaScript Application Framework
+// Copyright ©2006-2008, Sprout Systems, Inc. and contributors.
+// Portions copyright ©2008 Apple, Inc.  All rights reserved.
+// ========================================================================
+
+require('core') ;
+
+/**
+  This object can generate HTML DOM elements from a hash-based description of 
+  the nodes.  See the NodeDescriptor wiki page for complete docs.
+
+  See https://wiki.sproutit.com/engineering/show/NodeDescriptor 
+
+  @deprecated
+*/
+SC.NodeDescriptor = {
+  create: function(descriptor, opts) {
+    if (!opts) opts = {} ;
+    // collect info from descriptor
+    var tag = opts.tag || descriptor.tag || 'div' ;
+    var className = opts.cssClass || descriptor.cssClass ;
+    var elementId = opts.id || descriptor.id ;
+    var style = opts.style || descriptor.style ;
+    var innerHTML = opts.innerHTML || descriptor.innerHTML ;
+    if (!innerHTML) {
+      var childNodes = opts.childNodes || descriptor.childNodes ;
+    } 
+
+    // create element
+    var ret = $(document.createElement(tag)) ;
+    if (className) ret.className = className ;
+    if (elementId) ret.id = elementId ;
+    if (style) {
+      for (var name in style) element.style[name.camelize()] = style[name];
+    }
+    
+    // apply extra attributes
+    for(var attr in descriptor) {
+      if (this.ignoredProperties.indexOf(attr) == -1) {
+        ret.setAttribute(attr,descriptor[attr]) ;
+      }
+    }
+    
+    // build child nodes, if they exist.
+    if (innerHTML) {
+      ret.innerHTML = innerHTML ;
+    } else if (childNodes) {
+      var that = this ;
+      childNodes.each(function(desc) {
+        ret.appendChild(that.create(desc)) ;
+      }) ;
+	  that=null;
+	  childNodes=null;
+    }
+    
+	try{
+    	return ret ;
+	}finally{
+		//ie7 memory leaks
+		tag=null;
+		className=null;
+		elementId=null;
+		style=null;
+		innerHTML=null;
+		ret=null;
+	}
+  },
+  
+  ignoredProperties: ['tag','cssClass','id','style','childNodes','innerHTML']
+};
+