sproutit-sproutcore 1.0.0.20090407205609 → 1.0.0.20090408130025

data/frameworks/sproutcore/frameworks/foundation/system/locale.js

@@ -0,0 +1,288 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+/**
+  The Locale defined information about a specific locale, including date and
+  number formatting conventions, and localization strings.  You can define
+  various locales by adding them to the SC.locales hash, keyed by language
+  and/or country code.
+  
+  On page load, the default locale will be chosen based on the current 
+  languages and saved at SC.Locale.current.  This locale is used for 
+  localization, etc.
+  
+  h2. Creating a new locale
+  
+  You can create a locale by simply extending the SC.Locale class and adding
+  it to the locales hash:
+  
+  {{{
+    SC.Locale.locales['en'] = SC.Locale.extend({ .. config .. }) ;
+  }}}
+  
+  Alternatively, you could choose to base your locale on another locale by
+  extending that locale:
+  
+  {{{
+    SC.Locale.locales['en-US'] = SC.Locale.locales['en'].extend({ ... }) ;
+  }}}
+  
+  Note that if you do not define your own strings property, then your locale
+  will inherit any strings added to the parent locale.  Otherwise you must
+  implement your own strings instead.
+  
+  @extends SC.Object
+  @since SproutCore 1.0
+*/
+SC.Locale = SC.Object.extend({
+  
+  init: function() {
+    // make sure we know the name of our own locale.
+    if (!this.language) SC.Locale._assignLocales();
+    
+    // Make sure we have strings that were set using the new API.  To do this
+    // we check to a bool that is set by one of the string helpers.  This 
+    // indicates that the new API was used. If the new API was not used, we
+    // check to see if the old API was used (which places strings on the 
+    // String class). 
+    if (!this.hasStrings) {
+      var langs = this._deprecatedLanguageCodes || [] ;
+      langs.push(this.language);
+      var idx = langs.length ;
+      var strings = null ;
+      while(!strings && --idx >= 0) {
+        strings = String[langs[idx]];
+      }
+      if (strings) {
+        this.hasStrings = YES; 
+        this.strings = strings ;
+      }
+    }
+  },
+  
+  /** Set to YES when strings have been added to this locale. */
+  hasStrings: NO,
+  
+  /** The strings hash for this locale. */
+  strings: {},
+  
+  toString: function() {
+    if (!this.language) SC.Locale._assignLocales() ;
+    return "SC.Locale["+this.language+"]"+SC.guidFor(this) ;
+  },
+  
+  /** 
+    Returns the localized version of the string or the string if no match
+    was found.
+    
+    @param {String} string
+    @param {String} optional default string to return instead
+    @returns {String}
+  */
+  locWithDefault: function(string, def) {
+    return this.strings[string] || def || string ;
+  }
+  
+  
+}) ;
+
+SC.Locale.mixin(/** @scope SC.Locale */ {
+
+  /**
+    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,
+  
+  /** 
+    Invoked at the start of SproutCore's document onready handler to setup 
+    the currentLocale.  This will use the language properties you have set on
+    the locale to make a decision.
+  */
+  createCurrentLocale: function() {
+
+    // get values from String if defined for compatibility with < 1.0 build 
+    // tools.
+    var autodetect = (String.useAutodetectedLanguage !== undefined) ? String.useAutodetectedLanguage : this.useAutodetectedLanguage; 
+    var preferred = (String.preferredLanguage !== undefined) ? String.preferredLanguage : this.preferredLanguage ;
+
+    // determine the language
+    var lang = ((autodetect) ? SC.browser.language : null) || preferred || SC.browser.language || 'en';
+    lang = SC.Locale.normalizeLanguage(lang) ;
+
+    // get the locale class.  If a class cannot be found, fall back to generic
+    // language then to english.
+    var klass = this.localeClassFor(lang) ;
+
+    // if the detected language does not match the current language (or there
+    // is none) then set it up.
+    if (lang != this.currentLanguage) {
+      this.currentLanguage = lang ; // save language
+      this.currentLocale = klass.create(); // setup locale
+    }
+    return this.currentLocale ;
+  },
+
+  /**
+    Finds the locale class for the names language code or creates on based on
+    its most likely parent.
+  */
+  localeClassFor: function(lang) {
+    lang = SC.Locale.normalizeLanguage(lang) ;
+    var parent, klass = this.locales[lang];
+    
+    // if locale class was not found and there is a broader-based locale
+    // present, create a new locale based on that.
+    if (!klass && ((parent = lang.split('-')[0]) !== lang) && (klass = this.locales[parent])) {
+      klass = this.locales[lang] = klass.extend() ;      
+    }
+    
+    // otherwise, try to create a new locale based on english.
+    if (!klass) klass = this.locales[lang] = this.locales.en.extend();
+    
+    return klass;
+  },
+
+  /** 
+    Shorthand method to define the settings for a particular locale.
+    The settings you pass here will be applied directly to the locale you
+    designate.  
+
+    If you are already holding a reference to a locale definition, you can
+    also use this method to operate on the receiver.
+    
+    If the locale you name does not exist yet, this method will create the 
+    locale for you, based on the most closely related locale or english.  For 
+    example, if you name the locale 'fr-CA', you will be creating a locale for
+    French as it is used in Canada.  This will be based on the general French
+    locale (fr), since that is more generic.  On the other hand, if you create
+    a locale for manadarin (cn), it will be based on generic english (en) 
+    since there is no broader language code to match against.
+
+    @param {String} localeName
+    @param {Hash} options
+    @returns {SC.Locale} the defined locale
+  */
+  define: function(localeName, options) {
+    var locale ;
+    if (options===undefined && (SC.typeOf(localeName) !== SC.T_STRING)) {
+      locale = this; options = localeName ;
+    } else locale = SC.Locale.localeClassFor(localeName) ;
+    SC.mixin(locale.prototype, options) ;
+    return locale ;
+  },
+  
+  /**
+    Gets the current options for the receiver locale.  This is useful for 
+    inspecting registered locales that have not been instantiated.
+    
+    @returns {Hash} options + instance methods
+  */
+  options: function() { return this.prototype; },
+  
+  /**
+    Adds the passed hash of strings to the locale's strings table.  Note that
+    if the receiver locale inherits its strings from its parent, then the 
+    strings table will be cloned first.
+    
+    @returns {Object} receiver
+  */
+  addStrings: function(stringsHash) {
+    // make sure the target strings hash exists and belongs to the locale
+    var strings = this.prototype.strings ;
+    if (strings) {
+      if (!this.prototype.hasOwnProperty('strings')) {
+        this.prototype.strings = SC.clone(strings) ;
+      }
+    } else strings = this.prototype.strings = {} ;
+    
+    // add strings hash
+    if (stringsHash)  this.prototype.strings = SC.mixin(strings, stringsHash) ;
+    this.prototype.hasStrings = YES ;
+    return this;
+  },
+  
+  _map: { english: 'en', french: 'fr', german: 'de', japanese: 'ja', jp: 'ja', spanish: 'es' },
+  
+  /**
+    Normalizes the passed language into a two-character language code.
+    This method allows you to specify common languages in their full english
+    name (i.e. English, French, etc). and it will be treated like their two
+    letter code equivalent.
+    
+    @param {String} languageCode
+    @returns {String} normalized code
+  */
+  normalizeLanguage: function(languageCode) {
+    if (!languageCode) return 'en' ;
+    return SC.Locale._map[languageCode.toLowerCase()] || languageCode ;
+  },
+  
+  // this method is called once during init to walk the installed locales 
+  // and make sure they know their own names.
+  _assignLocales: function() {
+    for(var key in this.locales) this.locales[key].prototype.language = key;
+  },
+  
+  toString: function() {
+    if (!this.prototype.language) SC.Locale._assignLocales() ;
+    return "SC.Locale["+this.prototype.language+"]" ;
+  },
+  
+  // make sure important properties are copied to new class. 
+  extend: function() {
+    var ret= SC.Object.extend.apply(this, arguments) ;
+    ret.addStrings= SC.Locale.addStrings;
+    ret.define = SC.Locale.define ;
+    ret.options = SC.Locale.options ;
+    ret.toString = SC.Locale.toString ;
+    return ret ;
+  }
+    
+}) ;
+
+/** 
+  This locales hash contains all of the locales defined by SproutCore and
+  by your own application.  See the SC.Locale class definition for the
+  various properties you can set on your own locales.
+  
+  @property {Hash}
+*/
+SC.Locale.locales = {
+  en: SC.Locale.extend({ _deprecatedLanguageCodes: ['English'] }),
+  fr: SC.Locale.extend({ _deprecatedLanguageCodes: ['French'] }),
+  de: SC.Locale.extend({ _deprecatedLanguageCodes: ['German'] }),
+  ja: SC.Locale.extend({ _deprecatedLanguageCodes: ['Japanese', 'jp'] }),
+  es: SC.Locale.extend({ _deprecatedLanguageCodes: ['Spanish'] })
+} ;
+
+
+
+
+/**
+  This special helper will store the strings you pass in the locale matching
+  the language code.  If a locale is not defined from the language code you
+  specify, then one will be created for you with the english locale as the 
+  parent.
+  
+  @param {String} languageCode
+  @param {Hash} strings
+  @returns {Object} receiver 
+*/
+SC.stringsFor = function(languageCode, strings) {
+  // get the locale, creating one if needed.
+  var locale = SC.Locale.localeClassFor(languageCode);
+  locale.addStrings(strings) ;
+  return this ;
+} ;
+
+

data/frameworks/sproutcore/frameworks/foundation/system/page.js

@@ -0,0 +1,106 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+/**
+  @class SC.Page
+
+  A Page object is used to store a set of views that can be lazily configured
+  as needed.  The page object works by overloading the get() method.  The
+  first time you try to get the page
+  
+  @extends SC.Object
+*/
+SC.Page = SC.Object.extend(
+/** @scope SC.Page.prototype */ {
+  
+  /**
+    When you create a page, you can set it's "owner" property to an
+    object outside the page definition. This allows views in the page
+    to use the owner object as a target, (as well as other objects
+    accessible through the owner object). E.g.
+    
+    {{{
+      myButton: SC.ButtonView.design({
+        title: 'Click me',
+        target: SC.outlet('page.owner'),
+        action: 'buttonClicked'
+      })
+    }}}
+    
+    Usually, you'll set 'owner' to the object defined in core.js.
+  */
+  owner: null,
+  
+  get: function(key) {
+    var value = this[key] ;
+    if (value && value.isClass) {
+      this[key] = value = value.create({ page: this }) ;
+      if (!this.get('inDesignMode')) value.awake() ;
+      return value ;
+    } else return sc_super() ;
+  },
+  
+  /**
+    Finds all views defined on this page instances and builds them.  This is 
+    a quick, brute force way to wake up all of the views in a page object.  It
+    is not generally recommended. Instead, you should use get() or getPath() 
+    to retrieve views and rely on the lazy creation process to set them up.
+    
+    @return {SC.Page} receiver
+  */
+  awake: function() {
+    // step through all views and build them
+    for(var key in this) {
+      if (!this.hasOwnProperty(key)) continue ;
+      var value = this[key] ;
+      if (value && value.isViewClass) {
+        this[key] = value = value.create({ page: this }) ;
+      }
+    }
+    return this;
+  },
+
+  /**
+    Returns the named property unless the property is a view that has not yet
+    been configured.  In that case it will return undefined.  You can use this
+    method to safely get a view without waking it up.
+  */
+  getIfConfigured: function(key) {
+    var ret = this[key] ;
+    return (ret && ret.isViewClass) ? null : this.get(key);
+  },
+
+  /**
+    Applies a localization to every view builder defined on the page.  You must call this before you construct a view to apply the localization.
+  */
+  loc: function(locs) {
+    for(var key in locs) {
+      if (!locs.hasOwnProperty(key)) continue ;
+      var view = this[key] ;
+      if (!view || !view.isViewClass) continue ;
+      view.loc(locs[key]);
+    }
+    return this ;
+  }
+  
+  //needsDesigner: YES,
+  
+  //inDesignMode: YES
+    
+}) ;
+
+// ..........................................................
+// SUPPORT FOR LOADING PAGE DESIGNS
+// 
+
+/** Calling design() on a page is the same as calling create() */
+SC.Page.design = SC.Page.create ;
+
+/** Calling localization returns passed attrs. */
+SC.Page.localization = function(attrs) { return attrs; };
+
+

data/frameworks/sproutcore/frameworks/foundation/system/ready.js

@@ -0,0 +1,189 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2009 Sprout Systems, Inc. and contributors.
+//            Portions ©2008-2009 Apple, Inc. All rights reserved.
+// License:   Licened under MIT license (see license.js)
+// ==========================================================================
+
+/*global main */
+
+sc_require('system/event') ;
+
+SC.mixin({
+  _isReadyBound: NO,
+  
+  /** @private configures the ready event handler if needed */
+  _bindReady: function() {
+    if (this._isReadyBound) return;
+    this._isReadyBound = YES ;
+
+    // Mozilla, Opera (see further below for it) and webkit nightlies 
+    // currently support this event.  Use the handy event callback
+    if ( document.addEventListener && !SC.browser.opera) {
+      document.addEventListener( "DOMContentLoaded", SC._didBecomeReady, NO );
+    }
+
+    // If IE is used and is not in a frame
+    // Continually check to see if the document is ready
+    if (SC.browser.msie && (window === top)) {
+      (function() {
+        if (SC.isReady) return;
+        try {
+          // If IE is used, use the trick by Diego Perini
+          // http://javascript.nwbox.com/IEContentLoaded/
+          document.documentElement.doScroll("left");
+        } catch( error ) {
+          setTimeout( arguments.callee, 0 );
+          return;
+        }
+        // and execute any waiting functions
+        SC._didBecomeReady();
+      })();
+    }
+
+    if ( SC.browser.opera ) {
+      document.addEventListener( "DOMContentLoaded", function () {
+        if (SC.isReady) return;
+        for (var i = 0; i < document.styleSheets.length; i++) {
+          if (document.styleSheets[i].disabled) {
+            setTimeout( arguments.callee, 0 );
+            return;
+          }
+        }
+        // and execute any waiting functions
+        SC._didBecomeReady();
+      }, NO);
+    }
+
+    if ( SC.browser.safari ) {
+      console.log("ready() is not yet supported on Safari <= 3.1") ;
+      // var numStyles;
+      // (function(){
+      //   if (SC.isReady) return;
+      //   if ( document.readyState != "loaded" && document.readyState != "complete" ) {
+      //     setTimeout( arguments.callee, 0 );
+      //     return;
+      //   }
+      //   if ( numStyles === undefined ) numStyles = 0 ;
+      //     //numStyles = SC.$("style, link[rel=stylesheet]").length;
+      //   if ( document.styleSheets.length != numStyles ) {
+      //     setTimeout( arguments.callee, 0 );
+      //     return;
+      //   }
+      //   // and execute any waiting functions
+      //   SC._didBecomeReady();
+      // })();
+    }
+
+    // A fallback to window.onload, that will always work
+    SC.Event.add( window, "load", SC._didBecomeReady);
+  },
+
+  /** @private handlers scheduled to execute on ready. */
+  _readyQueue: [],
+  
+  _afterReadyQueue: [],
+
+  isReady: NO,
+  
+  /** @private invoked when the document becomes ready. */
+  _didBecomeReady: function() {
+    // Only call once
+    if (SC.isReady) return ;
+    
+    // setup locale
+    SC.Locale.createCurrentLocale();
+    
+    // if there is a body tag on the document, set the language
+    if (document && document.getElementsByTagName) {
+      var body = document.getElementsByTagName('body')[0];
+      if (body) {
+        var className = body.className ;
+        var language = SC.Locale.currentLanguage.toLowerCase() ;
+        body.className = (className && className.length>0) ? [className, language].join(' ') : language ;
+      }
+    }
+
+    SC.Benchmark.start('ready') ;
+    
+    // Begin runloop
+    SC.RunLoop.begin();
+    
+    var handler, ary, idx, len ;
+
+    // correctly handle queueing new SC.ready() calls
+    do {
+      ary = SC._readyQueue ;
+      SC._readyQueue = [] ; // reset
+      for (idx=0, len=ary.length; idx<len; idx++) {
+        handler = ary[idx] ;
+        var target = handler[0] || document ;
+        var method = handler[1] ;
+        if (method) method.call(target) ;
+      }
+    } while (SC._readyQueue.length > 0) ;
+
+    // okay, now we're ready (any SC.ready() calls will now be called immediately)
+    SC.isReady = YES ;
+    
+    // clear the queue
+    SC._readyQueue = null ;
+    
+    // trigger any bound ready events
+    SC.Event.trigger("ready", null, document, NO) ;
+    
+    // Remove any loading div
+    if (SC.removeLoading) SC.$('#loading').remove();
+    
+    // Now execute main, if defined
+    if ((typeof main != "undefined") && (main instanceof Function) && !SC.suppressMain) main();
+    
+    // handle routes, if modules is installed.
+    if (SC.Routes && SC.Routes.ping) SC.Routes.ping() ; 
+    
+    // end run loop.  This is probably where a lot of bindings will trigger
+    SC.RunLoop.end() ; 
+    
+    SC.Benchmark.end('ready') ;
+    SC.Benchmark.log();
+  },
+  
+  /** 
+    Add the passed target and method to the queue of methods to invoke when
+    the document is ready.  These methods will be called after the document
+    has loaded and parsed, but before the main() function is called.
+    
+    Methods are called in the order they are added.
+  
+    If you add a ready handler when the main document is already ready, then
+    your handler will be called immediately.
+    
+    @param target {Object} optional target object
+    @param method {Function} method name or function to execute
+    @returns {SC}
+  */
+  ready: function(target, method) {
+    var queue = this._readyQueue;
+    
+    // normalize
+    if (method === undefined) {
+      method = target; target = null ;
+    } else if (SC.typeOf(method) === SC.T_STRING) {
+      method = target[method] ;
+    }
+    
+    if (!method) return this; // nothing to do.
+    
+    // if isReady, execute now.
+    if (this.isReady) return method.call(target || document) ;
+    
+    // otherwise, add to queue.
+    queue.push([target, method]) ;
+    return this ; 
+  }
+  
+}) ;
+
+SC._bindReady() ;
+SC.removeLoading = YES;
+