sproutcore 1.6.0.beta.2-x86-mingw32

data/lib/frameworks/sproutcore/frameworks/desktop/views/popup_button.js

@@ -0,0 +1,303 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+sc_require('views/button');
+
+/** @class
+
+  SC.PopupButtonView displays a pop-up menu when clicked, from which the user
+  can select an item.
+
+  To use, create the SC.PopupButtonView as you would a standard SC.ButtonView,
+  then set the menu property to an instance of SC.MenuPane. For example:
+
+      SC.PopupButtonView.design({
+        layout: { width: 200, height: 18 },
+        menuBinding: 'MyApp.menuController.menuPane'
+      });
+
+  You would then have your MyApp.menuController return an instance of the menu
+  to display.
+
+  @extends SC.ButtonView
+  @author Santosh Shanbhogue
+  @author Tom Dale
+  @copyright 2008-2011, Strobe Inc. and contributors.
+  @version 1.0
+*/
+SC.PopupButtonView = SC.ButtonView.extend(
+/** @scope SC.PopupButtonView.prototype */ {
+
+  /**
+    @type Array
+    @default ['sc-popup-button']
+    @see SC.View#classNames
+  */
+  classNames: ['sc-popup-button'],
+
+  /**
+    @type String
+    @default 'popupButtonRenderDelegate'
+  */
+  renderDelegateName: 'popupButtonRenderDelegate',
+
+
+  // ..........................................................
+  // PROPERTIES
+  //
+
+  /**
+    The prefer matrix to use when displaying the menu.
+
+    @property
+  */
+  preferMatrix: null,
+
+  /**
+    The SC.MenuPane that should be displayed when the button is clicked.
+
+    @type {SC.MenuPane}
+    @default null
+  */
+  menu: null,
+  
+  /**
+    If YES and the menu is a class, this will cause a task that will instantiate the menu
+    to be added to SC.backgroundTaskQueue.
+    
+    @type Boolean
+    @default NO
+  */
+  shouldLoadInBackground: NO,
+
+  // ..........................................................
+  // INTERNAL SUPPORT
+  //
+  
+  /** @private
+    If necessary, adds the loading of the menu to the background task queue.
+  */
+  init: function() {
+    sc_super();
+    this._setupMenu();
+    if (this.get('shouldLoadInBackground')) {
+      SC.backgroundTaskQueue.push(SC.PopupButtonMenuLoader.create({ popupButton: this }));
+    }
+  },
+  
+  /** @private
+    Sets up binding on the menu, removing any old ones if necessary.
+  */
+  _setupMenu: function() {
+    var menu = this.get('instantiatedMenu');
+    
+    // clear existing bindings
+    if (this.isActiveBinding) this.isActiveBinding.disconnect();
+    this.isActiveBinding = null;
+    
+    // if there is a menu
+    if (menu && !menu.isClass) {
+      this.isActiveBinding = this.bind('isActive', menu, 'isVisibleInWindow');
+    }
+  },
+  
+  /** @private
+    Setup the bindings for menu...
+  */
+  _popup_menuDidChange: function() {
+    this._setupMenu();
+  }.observes('menu'),
+
+  /** @private
+    isActive is NO, but when the menu is instantiated, it is bound to the menu's isVisibleInWindow property.
+  */
+  isActive: NO,
+  
+  /** @private
+    Instantiates the menu if it is not already instantiated.
+  */
+  _instantiateMenu: function() {
+    // get menu
+    var menu = this.get('menu');
+    
+    // if it is already instantiated or does not exist, we cannot do anything
+    if (!menu || !menu.isClass) return;
+    
+    // create
+    this.menu = menu.create();
+    
+    // setup
+    this._setupMenu();
+  },
+  
+  /** @private
+    The guaranteed-instantiated menu.
+  */
+  instantiatedMenu: function() {
+    // get the menu
+    var menu = this.get('menu');
+    
+    // if it is a class, we need to instantiate it
+    if (menu && menu.isClass) {
+      // do so
+      this._instantiateMenu();
+      
+      // get the new version of the local
+      menu = this.get('menu');
+    }
+    
+    // return
+    return menu;
+  }.property('menu').cacheable(),
+
+  /** @private
+    Displays the menu.
+
+    @param {SC.Event} evt
+  */
+  action: function(evt)
+  {
+    var menu = this.get('instantiatedMenu') ;
+
+    if (!menu) {
+      //@ if (debug)
+      SC.Logger.warn("SC.PopupButton - Unable to show menu because the menu property is set to %@.".fmt(menu));
+      //@ endif
+      return NO ;
+    }
+
+    menu.popup(this, this.get('preferMatrix')) ;
+    return YES;
+  },
+
+  /** @private
+    On mouse down, we set the state of the button, save some state for further
+    processing, then call the button's action method.
+
+    @param {SC.Event} evt
+    @returns {Boolean}
+  */
+  mouseDown: function(evt) {
+    // If disabled, handle mouse down but ignore it.
+    if (!this.get('isEnabled')) return YES ;
+
+    this._isMouseDown = YES;
+
+    this._action() ;
+
+    // Store the current timestamp. We register the timestamp at the end of
+    // the runloop so that the menu has been rendered, in case that operation
+    // takes more than a few hundred milliseconds.
+
+    // One mouseUp, we'll use this value to determine how long the mouse was
+    // pressed.
+    this.invokeLast(this._recordMouseDownTimestamp);
+
+    this.becomeFirstResponder();
+
+    return YES ;
+  },
+
+  /** @private
+    Records the current timestamp. This is invoked at the end of the runloop
+    by mouseDown. We use this value to determine the delay between mouseDown
+    and mouseUp.
+  */
+  _recordMouseDownTimestamp: function() {
+    this._menuRenderedTimestamp = new Date().getTime();
+  },
+
+  /** @private
+    Because we responded YES to the mouseDown event, we have responsibility
+    for handling the corresponding mouseUp event.
+
+    However, the user may click on this button, then drag the mouse down to a
+    menu item, and release the mouse over the menu item. We therefore need to
+    delegate any mouseUp events to the menu's menu item, if one is selected.
+
+    We also need to differentiate between a single click and a click and hold.
+    If the user clicks and holds, we want to close the menu when they release.
+    Otherwise, we should wait until they click on the menu's modal pane before
+    removing our active state.
+
+    @param {SC.Event} evt
+    @returns {Boolean}
+  */
+  mouseUp: function(evt) {
+    var timestamp = new Date().getTime(),
+        previousTimestamp = this._menuRenderedTimestamp,
+        menu = this.get('instantiatedMenu'),
+        touch = SC.platform.touch,
+        targetMenuItem;
+
+    if (menu) {
+      // Get the menu item the user is currently hovering their mouse over
+      targetMenuItem = menu.getPath('rootMenu.targetMenuItem');
+
+      if (targetMenuItem) {
+        // Have the menu item perform its action.
+        // If the menu returns NO, it had no action to
+        // perform, so we should close the menu immediately.
+        if (!targetMenuItem.performAction()) menu.remove();
+      } else {
+        // If the user waits more than certain amount of time between
+        // mouseDown and mouseUp, we can assume that they are clicking and
+        // dragging to the menu item, and we should close the menu if they
+        //mouseup anywhere not inside the menu.
+        if (!touch && (timestamp - previousTimestamp > SC.ButtonView.CLICK_AND_HOLD_DELAY)) {
+          menu.remove();
+        }
+      }
+    }
+
+    // Reset state.
+    this._isMouseDown = NO;
+    sc_super();
+    return YES;
+  },
+
+  /** @private
+    Overrides ButtonView's mouseExited method to remove the behavior where the
+    active state is removed on mouse exit. We want the button to remain active
+    as long as the menu is visible.
+
+    @param {SC.Event} evt
+    @returns {Boolean}
+  */
+  mouseExited: function(evt) {
+    return YES;
+  },
+
+  /** @private
+    Overrides performKeyEquivalent method to pass any keyboard shortcuts to
+    the menu.
+
+    @param {String} charCode string corresponding to shortcut pressed (e.g.,
+    alt_shift_z)
+    @param {SC.Event} evt
+  */
+  performKeyEquivalent: function( charCode, evt )
+  {
+    if (!this.get('isEnabled')) return NO ;
+    var menu = this.get('instantiatedMenu') ;
+
+    return (!!menu && menu.performKeyEquivalent(charCode, evt, YES)) ;
+  }
+
+});
+
+/**
+  @private
+  Handles lazy instantiation of popup button menu.
+*/
+SC.PopupButtonMenuLoader = SC.Task.extend({
+  popupButton: null,
+  run: function() {
+    if (this.popupButton) this.popupButton._instantiateMenu();
+  }
+});
+

data/lib/frameworks/sproutcore/frameworks/desktop/views/progress.js

@@ -0,0 +1,259 @@
+// ==========================================================================
+// Project:   SproutCore - JavaScript Application Framework
+// Copyright: ©2006-2011 Strobe Inc. and contributors.
+//            Portions ©2008-2011 Apple Inc. All rights reserved.
+// License:   Licensed under MIT license (see license.js)
+// ==========================================================================
+
+/**
+  @class
+
+  Displays a progress bar.  You can display both a defined and an 
+  indeterminate progressbar.  The progress bar itself is designed to be styled
+  using CSS classes with the following structure:
+  
+      <div class="sc-progress-view"><div class="inner"></div></div>
+  
+  The outer can form the boundary of the bar while the inner will be adjusted 
+  to fit the percentage of the progress.
+  
+  Creating a ProgressView accepts a number of properties, for example:
+  
+      progressView: SC.ProgressView.design({
+        value: 50, 
+        minimum: 0, 
+        maximum: 100,
+        isIndeterminate: NO,
+        isEnabled: YES
+      })
+  
+  @extends SC.View
+  @extends SC.Control
+  @since SproutCore 1.0
+*/
+SC.ProgressView = SC.View.extend(SC.Control,
+/** @scope SC.ProgressView.prototype */{
+  
+  /**
+    @type Array
+    @default ['sc-progress-view']
+    @see SC.View#classNames
+  */
+  classNames: ['sc-progress-view'],
+  
+  /**
+    @type Array
+    @default 'displayValue ariaValue minimum maximum isRunning isEnabled isIndeterminate animatedBackgroundMatrix offsetRange'.w()
+    @see SC.View#displayProperties
+  */
+  displayProperties: ['displayValue', 'ariaValue', 'minimum', 'maximum', 'isRunning', 'isEnabled', 'isIndeterminate', 'animatedBackgroundMatrix', 'offsetRange'],
+
+  /**
+    @type String
+    @default 'progressRenderDelegate'
+  */
+  renderDelegateName: 'progressRenderDelegate',
+
+  // ........................................
+  // PROPERTIES
+  //
+
+  /**
+    Bind this to the current value of the progress bar.  Note that by default 
+    an empty value will disable the progress bar and a multiple value will make 
+    it indeterminate.
+    
+    @type Number
+    @default 0.50
+  */
+  value: 0.50,
+
+  /** @private */
+  valueBindingDefault: SC.Binding.single().notEmpty(),
+  
+  /**
+    @field
+    @type Number
+    @observes value
+    @observes maximum
+    @observes minimum
+  */
+  displayValue: function(){
+    var minimum = this.get('minimum') || 0.0,
+        maximum = this.get('maximum') || 1.0,
+        value = this.get('value') || 0.0;
+    value = (value - minimum) / (maximum - minimum);
+    if (value > 1.0) value = 1.0;
+
+    if(isNaN(value)) value = 0.0;
+    // cannot be smaller then minimum
+    if(value<minimum) value = 0.0;
+    // cannot be larger then maximum
+    if(value>maximum) value = 1.0;
+    
+    return value;
+  }.property('value', 'maximum', 'minimum').cacheable(),
+
+  /**
+    The WAI-ARIA role for progress view.
+
+    @type String
+    @default 'progressbar'
+    @readOnly
+  */
+  ariaRole: 'progressbar',
+
+  /**
+    The WAI-ARIA value for the progress view. This value will be passed to any
+    rendering code as-is, not converted into percentages, etc. It is computed
+    based on the original value property.
+
+    @property
+  */
+  ariaValue: function() {
+    return this.get('value');
+  }.property('value').cacheable(),
+  
+  /**
+    The minimum value of the progress.
+    
+    @type Number
+    @default 0
+  */ 
+  minimum: 0,
+  
+  /** @private */
+  minimumBindingDefault: SC.Binding.single().notEmpty(),
+
+  /**
+    Optionally specify the key used to extract the minimum progress value 
+    from the content object.  If this is set to null then the minimum value
+    will not be derived from the content object.
+    
+    @type String
+    @default null
+  */
+  contentMinimumKey: null,
+  
+  /**
+    The maximum value of the progress bar.
+    
+    @type Number
+    @default 1.0
+  */
+  maximum: 1.0,
+  
+  /** @private */
+  maximumBindingDefault: SC.Binding.single().notEmpty(),
+
+  /**
+    Deprecated. This is a render setting, and as such, should be adjusted in
+    the theme. Investigate your theme's progressRenderDelegate.
+    
+    @deprecated This should now be changed in themes.
+    @type Integer
+    @deprecated
+  */
+  offsetRange: undefined,
+
+  /**
+    Optionally specify the key used to extract the maximum progress value 
+    from the content object.  If this is set to null then the maximum value
+    will not be derived from the content object.
+    
+    @type String
+    @default null
+  */
+  contentMaximumKey: null,
+
+  /** 
+    Set to true if the item in progress is indeterminate.  This may be 
+    overridden by the actual value.
+    
+    @type Boolean
+    @default NO
+  */
+  isIndeterminate: NO,
+  
+  /** @private */
+  isIndeterminateBindingDefault: SC.Binding.bool(),
+
+  /**
+    Set to YES when the process is currently running.  This will cause the 
+    progress bar to animate, especially if it is indeterminate.
+    
+    @type Boolean
+    @default NO
+  */
+  isRunning: NO,
+  
+  /** @private */
+  isRunningBindingDefault: SC.Binding.bool(),
+
+  /** 
+    Set to the matrix used for background image position for animation.
+    [1st image y-location, offset, total number of images]
+    
+    @type Array
+    @default null
+  */
+  animatedBackgroundMatrix: null,
+  
+  /**
+    Optionally specify the key used to extract the isIndeterminate value 
+    from the content object.  If this is set to null then the isIndeterminate 
+    value will not be derived from the content object.
+    
+    @type String
+    @default null
+  */
+  contentIsIndeterminateKey: null,
+
+  
+  // ........................................
+  // INTERNAL SUPPORT
+  //
+
+  /** @private */
+  _backgroundOffset: 0,
+  
+  /** @private */
+  _currentBackground: 1,
+  
+  /** @private */
+  _nextBackground: 1,
+
+  /** @private */
+  init: function() {
+    sc_super();
+    this.animateProgressBar();
+  },
+  
+  /** @private */
+  animateProgressBar: function() {
+    if (this.get('isRunning') && this.get('isVisibleInWindow')) {
+      this._animateProgressBar(500); // wait to start to avoid probs
+    }
+  }.observes('isRunning', 'isVisibleInWindow'),
+
+  /** @private */
+  _animateProgressBar: function(delay) {
+    if (delay===0) delay = 1000/30;
+    if (this.get('isRunning') && this.get('isVisibleInWindow')) {
+      this.displayDidChange();
+      this.invokeLater(this._animateProgressBar, delay, 600);
+    }
+  },
+
+  /** @private */
+  contentPropertyDidChange: function(target, key) {
+    var content = this.get('content');
+    this.beginPropertyChanges()
+      .updatePropertyFromContent('value', key, 'contentValueKey', content)
+      .updatePropertyFromContent('minimum', key, 'contentMinimumKey', content)
+      .updatePropertyFromContent('maximum', key, 'contentMaximumKey', content)
+      .updatePropertyFromContent('isIndeterminate', key, 'contentIsIndeterminateKey', content)
+    .endPropertyChanges();
+  }
+
+});