sproutcore 0.9.0

data/frameworks/sproutcore/foundation/string.js

@@ -0,0 +1,149 @@
+// ==========================================================================
+// SproutCore -- JavaScript Application Framework
+// copyright 2006-2007, Sprout Systems, Inc. and contributors.
+// ==========================================================================
+
+// These are basic enhancements to the string class used throughout 
+// SproutCore.
+// capitalize a string.
+Object.extend(String.prototype,{
+
+  // Capitalize a string.
+  //
+  // mode: optional.  'each' - capitalize each word. the default.
+  //                  'first' - capitalize the first word only.
+  
+  capitalize: function(mode) {
+    var words = (mode == 'first') ? this : this.split(' ') ;
+    words = words.map(function(word) {
+      if (word.length == 0) return word ;
+      return word.charAt(0).toUpperCase() + word.substring(1) ;
+    }) ;
+    return words.join(' ') ;
+  },
+
+  // Interpolate string. looks for %@ or %@1; to control the order of params.
+  format: function() {
+    var args = $A(arguments) ;
+    
+    // first, replace any ORDERED replacements.
+    var str = this.gsub(/%@([0-9]+)/, function(m) {
+      return args[parseInt(m[1],0)-1] || ''; 
+    }) ;
+
+    // now, replace any remaining %@ items.  Use this indexOf() method b/c
+    // it is faster than split().
+    var ret = [] ;
+    var idx = -1 ;
+    var loc = 0 ;
+    while((idx = str.indexOf("%@",loc)) >= 0) {
+     // slice off initial part of string and push into ret. update loc.
+     ret.push(str.slice(loc,idx)) ;
+     loc = idx + 2 ; // 2 to skip '%@'.
+     
+     // add in replacement.
+     ret.push(args.shift()) ;
+    }
+    
+    // include any remaining bits of the string.
+    if (loc < str.length) {
+      ret.push(str.slice(loc,str.length)) ;
+    }
+    
+    // join return value.
+    return (ret.length > 1) ? ret.join('') : ret[0] ;
+  },
+
+  // localize a string.  Also interpolates any items you pass just like
+  // format().
+  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.
+    
+    var kit = String[String.currentLanguage()];
+    var str = kit[this] ;
+    if (!str) str = String.English[this] || this ;
+    return str.format.apply(str,arguments) ;
+  },
+  
+  // this works just like loc except it will return the first argument
+  // as a default if the matching value is not found.
+  locWithDefault: function(def) {
+    var kit = String[String.currentLanguage()];
+    var str = kit[this] ;
+    if (!str) str = String.English[this] || def ;
+    var args = $A(arguments) ;
+    args.shift() ; // escape def.
+    return str.format.apply(str, args) ;
+  },
+  
+  classify: function() {
+    return this.camelize().capitalize() ;
+  },
+  
+  decamelize: function() { 
+    return this.replace(/([a-z])([A-Z])/g,'$1_$2').toLowerCase();
+  },
+
+  dasherize: function() {
+    return this.decamelize().replace(/[ _]/g,'-') ;  
+  },
+  
+  humanize: function() {
+    return this.decamelize().replace(/[-_]/g,' ') ;
+  },
+  
+  toHref: function() {
+    if (this.match(/.+@.+\...+/)) {
+      return 'mailto:' + this;
+    } else if (this.indexOf('http://') != 0 && this.indexOf('https://') !=0 && this.match(/[^.]+\.[^.]+/)) {
+      return 'http://' + this;
+    } else {
+      return this;
+    }
+  },
+  
+  trim: function ()
+  {
+    return this.replace(/^\s+|\s+$/g,"");
+  },
+  
+  strip: function()
+  {
+    return this.trim();
+  }
+  
+}) ;
+
+// Shorter alias of the format function.
+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,{
+  
+  // Default language is English. Currently French, German, and Japanese are
+  // detected. All other languages default to English.
+  currentLanguage: function () {
+    var browserLanguage = (navigator.language || navigator.browserLanguage).split('-', 1);
+    switch(browserLanguage[0])
+    {
+      case 'fr':
+        return 'French';
+      case 'de':
+        return 'German';
+      case 'ja':
+        return 'Japanese';
+      default:
+        return 'English'; 
+    }
+  }
+
+});
+
+String.English  = String.English  || {};
+String.French   = String.French   || {};
+String.German   = String.German   || {};
+String.Japanese = String.Japanese || {};

data/frameworks/sproutcore/foundation/undo_manager.js

@@ -0,0 +1,186 @@
+// ==========================================================================
+// SproutCore -- JavaScript Application Framework
+// copyright 2006-2007, Sprout Systems, Inc. and contributors.
+// ==========================================================================
+
+require('Core');
+
+/**
+  @class
+  
+  This is a simple undo manager.  To use this UndoManager, all you need to
+  do is to make sure that you register a function with this manager to undo
+  every change you make.  You can then invoke the undo/redo methods to do it.
+  
+  h4. USING THE UNDOMANAGER
+  
+  Typically you create an undo manager inside on of your controllers.  Then,
+  whenever you are about to perform an action on your model object, all you
+  need to do is to register a function with the undo manager that can undo 
+  whatever  you just did.
+  
+  Besure the undo function you register also saves undo functions.  This makes
+  redo possible.
+  
+  More docs TBD.
+  
+  @extends SC.Object
+*/
+SC.UndoManager = SC.Object.extend(
+/** @scope SC.UndoManager.prototype */
+{
+
+  /** 
+    (Property) Name of the next undo action name.  
+  
+    Use this property to build your Undo menu name.
+    
+  */
+  undoActionName: function() { 
+    return (this.undoStack) ? this.undoStack.name : null ;
+  }.property('undoStack'),
+  
+  /** 
+    (Property) Name of the next return action name.  
+  
+    Use this property to build your Redo menu name.
+    
+  */
+  redoActionName: function() { 
+    return (this.redoStack) ? this.redoStack.name : null ;
+  }.property('redoStack'),
+
+  /** 
+    True if there is an undo action on the stack.
+    
+    Use to validate your menu item.
+  */
+  canUndo: function() { 
+    return this.undoStack != null; 
+  }.property('undoStack'),
+  
+  /** 
+    True if there is an redo action on the stack.
+    
+    Use to validate your menu item.
+  */
+  canRedo: function() { 
+    return this.redoStack != null; 
+  }.property('redoStack'),
+  
+  /**  
+    Tries to undo the last action.  
+  
+    Returns true if succeeded.  Fails if an undo group is currently open.
+  */
+  undo: function() { this._undoOrRedo('undoStack','isUndoing'); },
+  
+  /**  
+    Tries to redo the last action.  
+  
+    Returns true if succeeded.  Fails if an undo group is currently open.
+  */
+  redo: function() { this._undoOrRedo('redoStack','isRedoing'); },
+  
+  /**
+    True if the manager is currently undoing events. 
+  */
+  isUndoing: false, 
+  
+  /**
+    True if the manager is currently redoing events.
+  */
+  isRedoing: false, 
+  
+  /** @private */
+  groupingLevel: 0,
+  
+  // --------------------------------
+  // SIMPLE REGISTRATION
+  //
+  // These are the core method to register undo/redo events.
+  
+  /**
+    This is how you save new undo events.
+    
+    @param {Function} func A prebound function to be invoked when the undo executes.
+    @param {String} [name] An optional name for the undo.  If you are using 
+      groups, this is not necessary.
+  */
+  registerUndo: function(func, name) {
+    this.beginUndoGroup(name) ;
+    this._activeGroup.actions.push(func) ;
+    this.endUndoGroup(name) ;
+  },
+
+  /**
+    Begins a new undo groups
+
+    Whenver you start an action that you expect to need to bundle under a single
+    undo action in the menu, you should begin an undo group.  This way any
+    undo actions registered by other parts of the application will be
+    automatically bundled into this one action.
+    
+    When you are finished performing the action, balance this with a call to
+    endUndoGroup().
+  */
+  beginUndoGroup: function(name) {
+    // is a group already active? Just increment the counter.
+    if (this._activeGroup) {
+      this.groupingLevel++ ;
+      
+    // otherwise, create a new active group.  
+    } else {
+      var stack = (this.isUndoing) ? 'redoStack' : 'undoStack' ;
+      this._activeGroup = { name: name, actions: [], prev: this.get(stack) } ;
+      this.set(stack, this._activeGroup) ;
+      this.groupingLevel = 1 ;
+    }
+  },
+ 
+  /** end the undo group.  see beginUndoGroup() */
+  endUndoGroup: function(name) {
+    // if more than one groups are active, just decrement the counter.
+    if (!this._activeGroup) raise("endUndoGroup() called outside group.") ;
+    if (this.groupingLevel > 1) {
+      this.groupingLevel-- ;
+      
+    // otherwise, close out the current group.
+    } else {
+      this._activeGroup = null ; this.groupingLevel = 0 ;
+    }
+    this.propertyDidChange((this.isUndoing) ? 'redoStack' : 'undoStack') ;
+  },
+
+  /**
+    Change the name of the current undo group.  
+  
+    Normally you don't want to do this as it will effect the whole group.
+  */
+  setActionName: function(name) {
+    if (!this._activeGroup) raise("setActionName() called outside group.") ;
+    this._activeGroup.name = name ;
+  },
+  
+  // --------------------------------
+  // PRIVATE
+  //
+  _activeGroup: null, undoStack: null, redoStack: null, 
+  _undoOrRedo: function(stack,state) {
+    if (this._activeGroup) return false ;
+    if (this.get(stack) == null) return true; // noting to do.
+
+    this.set(state, true) ;
+    var group = this.get(stack) ;
+    this.set(stack, group.prev) ;
+    var action ;
+
+    var useGroup = group.actions.length > 1; 
+    if (useGroup) this.beginUndoGroup(group.name) ;
+    while(action = group.actions.pop()) { action(); }
+    if (useGroup) this.endUndoGroup(group.name) ;
+    
+    this.set(state, false) ;
+  }
+  
+}) ;